├── Ejercicios ├── Ejercicio #9 - Volumen 1 - 151 - Es matriz identidad │ ├── SantiagoToniollo09.py │ ├── Volumen 1 - 151 - Es matriz identidad.pdf │ ├── Resolución │ │ ├── Refinamiento - Volumen 1 - 151 - Es matriz identidad.pdf │ │ └── Volumen 1 - 151 - Es matriz identidad.py │ ├── paganiValentino.py │ ├── SantiagoGarcia.py │ ├── Lucianogoniat.py │ ├── facundosalera.py │ ├── matriz.py │ ├── lucasPonce.py │ ├── LeandroDidrig.py │ ├── joaquinrojas.py │ ├── AlbaHeredia.py │ ├── SantiagoToniollo.py │ ├── BenjaminVidela.py │ ├── NicolasCesolari.py │ ├── AbrilCarballo.py │ └── lautaroVillarreal.py ├── Ejercicio #2 - Buscaminas │ ├── enunciado.pdf │ ├── Resolucion │ │ ├── Campos de minas - Explicación de resolución.pdf │ │ └── resolucionProfes.py │ ├── TiagoWenger.py │ ├── jesusPerochino.py │ ├── pedroRingelmann.py │ ├── mateoMaggi.py │ ├── victoriaPetry.py │ ├── gianellaRocha.py │ └── roldanLautaro.py ├── Ejercicio #3 - Cadenas ADN │ ├── enunciado.pdf │ ├── facundosalera.py │ ├── Ejercicio #3 - Santiago Garcia.py │ ├── TiagoWenger.py │ ├── lautaroRoldan.py │ └── Resolucion │ │ ├── resolucionProfes.py │ │ └── Resolución cadenas ADN sin append + paso a paso + comentarios.py ├── Ejercicio #1 - Espiral Galactica │ ├── enunciado.pdf │ ├── Resolucion │ │ ├── Espiral Galáctica - Explicación de resolución.pdf │ │ └── resoluciónProfes.py │ ├── jesusPerochino.py │ ├── lautaroRoldan.py │ ├── AgustinMagallanes.py │ └── EstebanAballay.py ├── Ejercicio #4 - Diamantes y Arena │ ├── enunciado.pdf │ ├── facundosalera.py │ ├── Ejercicio #4 - Marcos Elizondo.py │ ├── valentinoPagani.py │ ├── pedroRingelmann#3.py │ ├── lautaroRoldan.py │ ├── BiancaPetrucci.py │ ├── LaraAnselmi.py │ ├── diamantes-arenas.py │ ├── TiagoWenger.py │ ├── jesusPerochino.py │ ├── Ejercicio #4 - Santiago Garcia │ ├── JorgeQuipildor#4.py │ ├── AbrilCarballo.py │ ├── diamantes arena Lautaro Villarreal.py │ ├── mateoMaggi.py │ ├── AlbaHeredia.py │ ├── lucasPonce.py │ ├── gianeRocha.py │ └── Resolucion │ │ └── resoluciónProfes.py ├── Ejercicio #5 - Tiempo del evento │ ├── enunciado.pdf │ ├── pedroRingelmann.py │ ├── jesusPerochino.py │ ├── quipildorJorge.py │ ├── RoldanLautaro.py │ ├── ValentinoPagani.py │ └── resolucionProfes.py ├── Ejercicio #0 - Matrices Triangulares │ ├── enunciado.pdf │ ├── Resolucion │ │ ├── Resolución - MatricesTriangulares.pdf │ │ └── resoluciónProfes.py │ ├── elbaCorti.py │ ├── valentinomoreno │ │ └── ejercicio0 │ │ │ └── ejercicio0.py │ ├── TiagoWenger.py │ ├── LeandroDidrig.py │ ├── lucianogoniat.py │ ├── jesusPerochino.py │ ├── lautaroRoldan.py │ ├── victoriaPetry.py │ ├── Ejercicio #0 - Marcos_Elizondo.py │ ├── mateoMaggi.py │ ├── pedroRingelmann.py │ ├── EstebanAballay.py │ └── SantiagoGomez.py ├── Ejercicio #16 - Volumen 4 - 400 - Durmiendo en albergues │ ├── Ejercicio #16 - Marcos Elizondo.py │ ├── Volumen 4 - 400 - Durmiendo en albergues.pdf │ ├── Resolución │ │ ├── Refinamiento - Volumen 4 – 400 - Durmiendo en albergues .pdf │ │ └── Volumen 4 - 400 - Durmiendo en albergues.py │ ├── TiagoWenger.py │ ├── facundosalera.py │ ├── Durmiendo en Albergues Lautaro Villarreal.py │ ├── AlbaHeredia.py │ ├── AbrilCarballo.py │ └── Ejercicio #16 - Santiago Garcia.py ├── Ejercicio #12 - Volumen 1 - 163 - Súmale 1 │ ├── Volumen 1 - 163 - Súmale 1.pdf │ └── Resolución │ │ ├── Refinamiento - Volumen 1 – 163 – Súmale 1.pdf │ │ └── Volumen 1 - 163 - Súmale 1.py ├── Ejercicio #13 - Volumen 1 - 167 - Pintando Fractales │ ├── Ejercicio #13 - Santiago Garcia │ ├── lucasPonce.py │ ├── Volumen 1 - 167 - Pintando Fractales.pdf │ ├── Resolución │ │ ├── Refinamiento - Volumen 1 – 167 – Pintando Fractales .pdf │ │ ├── Volumen 1 - 167 - Pintando Fractales.py │ │ └── SantiagoToniollo.py │ ├── facundosalera.py │ ├── AlbaHeredia.py │ └── AbrilCarballo.py ├── Ejercicio #8 - Volumen 1 - 148 - Nochevieja │ ├── Volumen 1 - 148 - Nochevieja.pdf │ ├── Resolución │ │ ├── Refinamiento - Volumen 1 - 148 - Nochevieja.pdf │ │ └── Volumen 1 - 148 - Nochevieja.py │ ├── ValentinoPagani.py │ └── lucianogoniat.py ├── Ejercicio #14 - Volumen 1 - 176 - Campo de Minas │ ├── Volumen 1 - 176 - Campo de Minas.pdf │ └── Resolución │ │ └── Volumen 1 - 176 - Campo de Minas.py ├── Ejercicio #11 - Volumen 1 - 162 - Tableros de Ajedrez │ ├── Volumen 1 - 162 - Tableros de Ajedrez.pdf │ └── Resolución │ │ ├── Refinamiento - Volumen 1 – 162 – Tableros de Ajedrez .pdf │ │ └── Volumen 1 - 162 - Tableros de Ajedrez.py ├── Ejercicio #15 - Volumen 1 - 197 - Mensaje interceptado │ ├── Volumen 1 - 197 - Mensaje interceptado.pdf │ └── Resolución │ │ └── Volumen 1 - 197 - Mensaje interceptado.py ├── Ejercicio #6 - Volumen 1 - 100 - Constante de Kaprekar │ ├── Volumen 1 - 100 - Constante de Kaprekar.pdf │ ├── Resolución │ │ ├── Refinamiento - Volumen 1 –100 - Constante de Kaprekar.pdf │ │ └── Volumen 1 - 100 - Constante de Kaprekar.py │ └── ValentinoPagani.py ├── Ejercicio #7 - Volumen 1 - 107 - Aproximación de gauss │ ├── Volumen 1 - 107 - Aproximación de gauss.pdf │ └── Resolución │ │ ├── Refinamiento - Volumen 1 - 107 - Aproximación de gauss.pdf │ │ └── Volumen 1 - 107 - Aproximación de gauss.py └── Ejercicio #10 - Volumen 1 - 154 - Cuál es la siguiente matrícula │ ├── Volumen 1 - 154 - Cuál es la siguiente matrícula.pdf │ └── Resolución │ ├── Refinamiento - Volumen 1 - 154 - Cuál es la siguiente matrícula.pdf │ └── Volumen 1 - 154 - Cuál es la siguiente matrícula.py ├── Ejercicio #4 - Goniat luciano ├── MatiasRomero.py ├── LICENSE └── README.md /Ejercicios/Ejercicio #9 - Volumen 1 - 151 - Es matriz identidad/SantiagoToniollo09.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #2 - Buscaminas/enunciado.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vterreno/ejercicios-curso-python/HEAD/Ejercicios/Ejercicio #2 - Buscaminas/enunciado.pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #3 - Cadenas ADN/enunciado.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vterreno/ejercicios-curso-python/HEAD/Ejercicios/Ejercicio #3 - Cadenas ADN/enunciado.pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #1 - Espiral Galactica/enunciado.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vterreno/ejercicios-curso-python/HEAD/Ejercicios/Ejercicio #1 - Espiral Galactica/enunciado.pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #4 - Diamantes y Arena/enunciado.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vterreno/ejercicios-curso-python/HEAD/Ejercicios/Ejercicio #4 - Diamantes y Arena/enunciado.pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #5 - Tiempo del evento/enunciado.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vterreno/ejercicios-curso-python/HEAD/Ejercicios/Ejercicio #5 - Tiempo del evento/enunciado.pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #0 - Matrices Triangulares/enunciado.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vterreno/ejercicios-curso-python/HEAD/Ejercicios/Ejercicio #0 - Matrices Triangulares/enunciado.pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #16 - Volumen 4 - 400 - Durmiendo en albergues/Ejercicio #16 - Marcos Elizondo.py: -------------------------------------------------------------------------------- 1 | { 2 | "folders": [ 3 | { 4 | "path": "." 5 | } 6 | ], 7 | "settings": {} 8 | } -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #12 - Volumen 1 - 163 - Súmale 1/Volumen 1 - 163 - Súmale 1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vterreno/ejercicios-curso-python/HEAD/Ejercicios/Ejercicio #12 - Volumen 1 - 163 - Súmale 1/Volumen 1 - 163 - Súmale 1.pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #13 - Volumen 1 - 167 - Pintando Fractales/Ejercicio #13 - Santiago Garcia: -------------------------------------------------------------------------------- 1 | caso=int(input()) 2 | acum=0 3 | cont=0 4 | while caso!=0: 5 | cont+=1 6 | acum+=caso*2**(cont*2) 7 | caso=caso//2 8 | print(acum) 9 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #8 - Volumen 1 - 148 - Nochevieja/Volumen 1 - 148 - Nochevieja.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vterreno/ejercicios-curso-python/HEAD/Ejercicios/Ejercicio #8 - Volumen 1 - 148 - Nochevieja/Volumen 1 - 148 - Nochevieja.pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #2 - Buscaminas/Resolucion/Campos de minas - Explicación de resolución.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vterreno/ejercicios-curso-python/HEAD/Ejercicios/Ejercicio #2 - Buscaminas/Resolucion/Campos de minas - Explicación de resolución.pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #0 - Matrices Triangulares/Resolucion/Resolución - MatricesTriangulares.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vterreno/ejercicios-curso-python/HEAD/Ejercicios/Ejercicio #0 - Matrices Triangulares/Resolucion/Resolución - MatricesTriangulares.pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #14 - Volumen 1 - 176 - Campo de Minas/Volumen 1 - 176 - Campo de Minas.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vterreno/ejercicios-curso-python/HEAD/Ejercicios/Ejercicio #14 - Volumen 1 - 176 - Campo de Minas/Volumen 1 - 176 - Campo de Minas.pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #13 - Volumen 1 - 167 - Pintando Fractales/lucasPonce.py: -------------------------------------------------------------------------------- 1 | N = int(input()) 2 | contador = 1 3 | lados = N * 4 4 | 5 | while N != 1: 6 | N = N // 2 7 | lados += (N * 4 * (4**contador)) 8 | contador += 1 9 | 10 | print(lados) -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #1 - Espiral Galactica/Resolucion/Espiral Galáctica - Explicación de resolución.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vterreno/ejercicios-curso-python/HEAD/Ejercicios/Ejercicio #1 - Espiral Galactica/Resolucion/Espiral Galáctica - Explicación de resolución.pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #13 - Volumen 1 - 167 - Pintando Fractales/Volumen 1 - 167 - Pintando Fractales.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vterreno/ejercicios-curso-python/HEAD/Ejercicios/Ejercicio #13 - Volumen 1 - 167 - Pintando Fractales/Volumen 1 - 167 - Pintando Fractales.pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #9 - Volumen 1 - 151 - Es matriz identidad/Volumen 1 - 151 - Es matriz identidad.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vterreno/ejercicios-curso-python/HEAD/Ejercicios/Ejercicio #9 - Volumen 1 - 151 - Es matriz identidad/Volumen 1 - 151 - Es matriz identidad.pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #11 - Volumen 1 - 162 - Tableros de Ajedrez/Volumen 1 - 162 - Tableros de Ajedrez.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vterreno/ejercicios-curso-python/HEAD/Ejercicios/Ejercicio #11 - Volumen 1 - 162 - Tableros de Ajedrez/Volumen 1 - 162 - Tableros de Ajedrez.pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #12 - Volumen 1 - 163 - Súmale 1/Resolución/Refinamiento - Volumen 1 – 163 – Súmale 1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vterreno/ejercicios-curso-python/HEAD/Ejercicios/Ejercicio #12 - Volumen 1 - 163 - Súmale 1/Resolución/Refinamiento - Volumen 1 – 163 – Súmale 1.pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #15 - Volumen 1 - 197 - Mensaje interceptado/Volumen 1 - 197 - Mensaje interceptado.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vterreno/ejercicios-curso-python/HEAD/Ejercicios/Ejercicio #15 - Volumen 1 - 197 - Mensaje interceptado/Volumen 1 - 197 - Mensaje interceptado.pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #6 - Volumen 1 - 100 - Constante de Kaprekar/Volumen 1 - 100 - Constante de Kaprekar.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vterreno/ejercicios-curso-python/HEAD/Ejercicios/Ejercicio #6 - Volumen 1 - 100 - Constante de Kaprekar/Volumen 1 - 100 - Constante de Kaprekar.pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #7 - Volumen 1 - 107 - Aproximación de gauss/Volumen 1 - 107 - Aproximación de gauss.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vterreno/ejercicios-curso-python/HEAD/Ejercicios/Ejercicio #7 - Volumen 1 - 107 - Aproximación de gauss/Volumen 1 - 107 - Aproximación de gauss.pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #16 - Volumen 4 - 400 - Durmiendo en albergues/Volumen 4 - 400 - Durmiendo en albergues.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vterreno/ejercicios-curso-python/HEAD/Ejercicios/Ejercicio #16 - Volumen 4 - 400 - Durmiendo en albergues/Volumen 4 - 400 - Durmiendo en albergues.pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #8 - Volumen 1 - 148 - Nochevieja/Resolución/Refinamiento - Volumen 1 - 148 - Nochevieja.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vterreno/ejercicios-curso-python/HEAD/Ejercicios/Ejercicio #8 - Volumen 1 - 148 - Nochevieja/Resolución/Refinamiento - Volumen 1 - 148 - Nochevieja.pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #10 - Volumen 1 - 154 - Cuál es la siguiente matrícula/Volumen 1 - 154 - Cuál es la siguiente matrícula.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vterreno/ejercicios-curso-python/HEAD/Ejercicios/Ejercicio #10 - Volumen 1 - 154 - Cuál es la siguiente matrícula/Volumen 1 - 154 - Cuál es la siguiente matrícula.pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #13 - Volumen 1 - 167 - Pintando Fractales/Resolución/Refinamiento - Volumen 1 – 167 – Pintando Fractales .pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vterreno/ejercicios-curso-python/HEAD/Ejercicios/Ejercicio #13 - Volumen 1 - 167 - Pintando Fractales/Resolución/Refinamiento - Volumen 1 – 167 – Pintando Fractales .pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #9 - Volumen 1 - 151 - Es matriz identidad/Resolución/Refinamiento - Volumen 1 - 151 - Es matriz identidad.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vterreno/ejercicios-curso-python/HEAD/Ejercicios/Ejercicio #9 - Volumen 1 - 151 - Es matriz identidad/Resolución/Refinamiento - Volumen 1 - 151 - Es matriz identidad.pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #11 - Volumen 1 - 162 - Tableros de Ajedrez/Resolución/Refinamiento - Volumen 1 – 162 – Tableros de Ajedrez .pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vterreno/ejercicios-curso-python/HEAD/Ejercicios/Ejercicio #11 - Volumen 1 - 162 - Tableros de Ajedrez/Resolución/Refinamiento - Volumen 1 – 162 – Tableros de Ajedrez .pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #6 - Volumen 1 - 100 - Constante de Kaprekar/Resolución/Refinamiento - Volumen 1 –100 - Constante de Kaprekar.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vterreno/ejercicios-curso-python/HEAD/Ejercicios/Ejercicio #6 - Volumen 1 - 100 - Constante de Kaprekar/Resolución/Refinamiento - Volumen 1 –100 - Constante de Kaprekar.pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #7 - Volumen 1 - 107 - Aproximación de gauss/Resolución/Refinamiento - Volumen 1 - 107 - Aproximación de gauss.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vterreno/ejercicios-curso-python/HEAD/Ejercicios/Ejercicio #7 - Volumen 1 - 107 - Aproximación de gauss/Resolución/Refinamiento - Volumen 1 - 107 - Aproximación de gauss.pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #16 - Volumen 4 - 400 - Durmiendo en albergues/Resolución/Refinamiento - Volumen 4 – 400 - Durmiendo en albergues .pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vterreno/ejercicios-curso-python/HEAD/Ejercicios/Ejercicio #16 - Volumen 4 - 400 - Durmiendo en albergues/Resolución/Refinamiento - Volumen 4 – 400 - Durmiendo en albergues .pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #10 - Volumen 1 - 154 - Cuál es la siguiente matrícula/Resolución/Refinamiento - Volumen 1 - 154 - Cuál es la siguiente matrícula.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vterreno/ejercicios-curso-python/HEAD/Ejercicios/Ejercicio #10 - Volumen 1 - 154 - Cuál es la siguiente matrícula/Resolución/Refinamiento - Volumen 1 - 154 - Cuál es la siguiente matrícula.pdf -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #13 - Volumen 1 - 167 - Pintando Fractales/facundosalera.py: -------------------------------------------------------------------------------- 1 | def fractal(num,c): 2 | if int(num/(2**(c-1)))==0: 3 | return 0 4 | else: 5 | return(int(num/(2**(c-1)))*(4**c)+fractal(num,c+1)) 6 | n=int(input()) 7 | for _ in range(n): 8 | c=1 9 | num=int(input()) 10 | sum=fractal(num,c) 11 | print(sum) 12 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #8 - Volumen 1 - 148 - Nochevieja/ValentinoPagani.py: -------------------------------------------------------------------------------- 1 | horario = input().split(':') 2 | hora = horario[0] 3 | min = horario[1] 4 | 5 | if hora[0] == '0': 6 | hora = int(hora[1]) 7 | else: 8 | hora = int(hora) 9 | if min[0] == '0': 10 | min = int(min[1]) 11 | else: 12 | min = int(min) 13 | 14 | print(((24 - hora) * 60) - min) 15 | -------------------------------------------------------------------------------- /Ejercicio #4 - Goniat luciano: -------------------------------------------------------------------------------- 1 | n=int(input()) 2 | for i in range(n): 3 | cadena=str(input()) 4 | cont=0 5 | indice=0 6 | 7 | for x in range(len(cadena)): 8 | 9 | if cadena[x] == "<": 10 | indice += 1 11 | elif cadena[x] == ">" and indice > 0: 12 | 13 | indice -= 1 #aca encontre el diamante y lo resto 14 | cont += 1 15 | 16 | print(cont) 17 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #13 - Volumen 1 - 167 - Pintando Fractales/Resolución/Volumen 1 - 167 - Pintando Fractales.py: -------------------------------------------------------------------------------- 1 | #INICIALIZACIÓN DE VARIABLES 2 | contador = 1 3 | 4 | #ENTRADAS 5 | longitud = int(input()) 6 | 7 | #PROCESOS 8 | perímetro = longitud * 4 9 | 10 | while longitud != 1: 11 | perímetro = perímetro + ((4**contador)*(int(longitud/2))*4) 12 | contador = contador + 1 13 | longitud = int(longitud/2) 14 | 15 | print(perímetro) -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #4 - Diamantes y Arena/facundosalera.py: -------------------------------------------------------------------------------- 1 | n=int(input()) 2 | for i in range(n): 3 | c=0 #contador "<" 4 | cd=0 # contador diamantes 5 | e=str(input()) 6 | for z in range(len(e)): 7 | #encontramos "<" 8 | if e[z]=="<": 9 | c+=1 10 | #encontramos ">" y si ya encontramos "<" anteriormente entonces encontramos un diamante 11 | elif e[z]==">" and c>0: 12 | c-=1 13 | cd+=1 14 | print(cd) 15 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #13 - Volumen 1 - 167 - Pintando Fractales/Resolución/SantiagoToniollo.py: -------------------------------------------------------------------------------- 1 | casos = int(input()) 2 | resultados = "" 3 | 4 | for i in range(casos): 5 | contador = 1 6 | longitud = int(input()) 7 | perimetro = longitud * 4 8 | 9 | while longitud > 1: 10 | perimetro += (4**contador) * (int(longitud/2)) * 4 11 | contador += 1 12 | longitud //= 2 13 | 14 | resultados += "\n" + str(perimetro) 15 | 16 | print(resultados) -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #8 - Volumen 1 - 148 - Nochevieja/lucianogoniat.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | n=int(input()) 4 | guardo="" 5 | guardo2="" 6 | for i in range(n): 7 | horas=str(input()) 8 | for n in range(len(horas)): 9 | 10 | if horas[n] != ":": 11 | guardo2 += horas[n] 12 | 13 | if horas[n] == ":": 14 | guardo=guardo2 15 | guardo2="" 16 | h=23-int(guardo) 17 | m=(59-int(guardo2))+1 18 | 19 | j= h * 60 20 | suma =j + m 21 | print(suma) 22 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #4 - Diamantes y Arena/Ejercicio #4 - Marcos Elizondo.py: -------------------------------------------------------------------------------- 1 | n=int(input()) 2 | while n!=0: 3 | cuenta=0 4 | cuenta2=0 5 | linea=input() 6 | for i in range(len(linea)-1): 7 | if linea[i]=="<": 8 | cuenta+=1 9 | if linea[i]==">" and cuenta!=0: 10 | if cuenta2+1<=cuenta: 11 | cuenta2+=1 12 | if linea[len(linea)-1] == '>' and cuenta2+1<=cuenta: 13 | cuenta2+=1 14 | 15 | print (cuenta2) 16 | 17 | n-=1 18 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #13 - Volumen 1 - 167 - Pintando Fractales/AlbaHeredia.py: -------------------------------------------------------------------------------- 1 | Casos = int(input()) 2 | 3 | for i in range(Casos): 4 | Longitud = int(input()) 5 | 6 | Exp_4 = 1 #potencias de 4 7 | 8 | Tinta = Longitud * 4 #cuadrado grande 9 | 10 | while Longitud != 1: 11 | 12 | Longitud=Longitud//2 #reduzco el cuadrado a la mitad 13 | 14 | Tinta = Tinta + (Longitud*4) * (4 ** Exp_4) 15 | 16 | Exp_4 += 1 17 | 18 | print(Tinta) 19 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #4 - Diamantes y Arena/valentinoPagani.py: -------------------------------------------------------------------------------- 1 | n = int(input()) 2 | for _ in range(n): 3 | entrada = input() 4 | conta = 0 5 | contc = 0 6 | diamantes = 0 7 | estado = False 8 | for i in entrada: 9 | if i == '<': 10 | conta += 1 11 | estado = True 12 | if i == '>' and estado: 13 | contc += 1 14 | if contc >= conta: 15 | diamantes = conta 16 | else: 17 | diamantes = contc 18 | print(diamantes) 19 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #0 - Matrices Triangulares/elbaCorti.py: -------------------------------------------------------------------------------- 1 | def matriz_triangular(matriz, n): 2 | for i in range(n): 3 | for j in range(i + 1, n): 4 | if matriz[i][j] != 0: 5 | return "SI" 6 | return "NO" 7 | 8 | while True: 9 | n = int(input()) 10 | if n == 0: 11 | break 12 | 13 | matriz = [] 14 | for _ in range(n): 15 | fila = list(map(int, input().split())) 16 | matriz.append(fila) 17 | 18 | resultado = matriz_triangular(matriz, n) 19 | print(resultado) 20 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #4 - Diamantes y Arena/pedroRingelmann#3.py: -------------------------------------------------------------------------------- 1 | a = int(input()) 2 | vector = [0] * a 3 | 4 | for i in range(a): 5 | pal = str(input()) 6 | v = [] 7 | for j in range(len(pal)): 8 | v.append(pal[j]) 9 | print(v) 10 | for h in range(len(v)): 11 | if v[h] == "<": 12 | for m in range(h+1, len(v)): 13 | if v[m] == ">": 14 | vector[i] = vector[i] + 1 15 | v[m] = "." 16 | 17 | for i in range(a): 18 | print(vector[i]) 19 | 20 | 21 | 22 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #5 - Tiempo del evento/pedroRingelmann.py: -------------------------------------------------------------------------------- 1 | #Inicio 2 | DiaI=int(input('Dia ')) 3 | horaI=str(input()) 4 | x=horaI.split(':') 5 | 6 | #Final 7 | DiaF=int(input('Dia ')) 8 | horaF=str(input()) 9 | z=horaF.split(':') 10 | 11 | #Dia total 12 | totalD=DiaF-DiaI-1 13 | #Tiempo 14 | horas=24-int(x[0])+int(z[0]) 15 | minutos=int(z[1])-int(x[1]) 16 | if minutos==0: 17 | minutos=1 18 | segundos=int(z[2])-int(x[2]) 19 | 20 | print(f'{totalD} dia(s)') 21 | print(f'{horas} hora(s)') 22 | print(f'{minutos} minuto(s)') 23 | print(f'{segundos} segundo(s)') -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #13 - Volumen 1 - 167 - Pintando Fractales/AbrilCarballo.py: -------------------------------------------------------------------------------- 1 | def main(): 2 | cp = int(input('Casos de prueba: ')) 3 | 4 | for i in range(cp): 5 | n = int(input('Numeros: ')) 6 | if n == 1: 7 | print(4) 8 | else: 9 | total = fractal(n) 10 | print(total) 11 | 12 | def fractal(n): 13 | exponente = 1 14 | total = 4 * n 15 | while n != 1: 16 | n = n // 2 17 | total += (4 * n) * (4 ** exponente) 18 | exponente += 1 19 | return total 20 | main() 21 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #16 - Volumen 4 - 400 - Durmiendo en albergues/TiagoWenger.py: -------------------------------------------------------------------------------- 1 | gral=input() 2 | camas=[0]*1000 3 | cont=0 4 | may=0 5 | for i in range(len(gral)): 6 | if gral[i]=="X": 7 | camas[cont]=i 8 | cont+=1 9 | for i in range(1,cont): 10 | dif=(camas[i]-camas[i-1])-1 11 | if (dif%2)==0: 12 | dist=(dif/2)-1 13 | else: 14 | dist=dif//2 15 | if dist>may: 16 | may=dist 17 | if (camas[0]-1)>may: 18 | may=(camas[0]-1) 19 | bord=len(gral)-camas[cont-1]- 1 20 | if bord>may: 21 | may=bord 22 | print(may) 23 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #4 - Diamantes y Arena/lautaroRoldan.py: -------------------------------------------------------------------------------- 1 | a = int(input()) 2 | vector =[0]*a 3 | 4 | def sep(palabra): 5 | vec =[] 6 | for i in range(len(palabra)): 7 | vec.append(palabra[i]) 8 | return vec 9 | 10 | for i in range(a): 11 | pal = str(input()) 12 | vec = sep(pal) 13 | for h in range(len(vec)): 14 | if vec[h] == "<": 15 | for m in range(h+1,len(vec)): 16 | if vec[m] == ">": 17 | vector[i] = vector[i] + 1 18 | vec[m] = "." 19 | 20 | for i in range(a): 21 | print(vector[i]) -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #4 - Diamantes y Arena/BiancaPetrucci.py: -------------------------------------------------------------------------------- 1 | def contar_diam(diamantes): 2 | diamnte = [] 3 | c2 = 0 4 | for i in range(len(diamantes)): 5 | if diamantes[i]== "<": 6 | diamnte.append(diamantes[i]) 7 | elif diamantes[i] == ">"and diamnte: 8 | diamnte.pop() 9 | c2 += 1 10 | return c2 11 | 12 | 13 | # Ingresar la cantidad de pruebas 14 | cantidad_pruebas = int(input(" ")) 15 | # Realizar las pruebas 16 | for _ in range(cantidad_pruebas): 17 | diamantes = str(input("")) 18 | resultado = contar_diam(diamantes) 19 | print(resultado) -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #4 - Diamantes y Arena/LaraAnselmi.py: -------------------------------------------------------------------------------- 1 | 2 | def contardiamantes (diamantes): 3 | diam = [] 4 | diamantes1 = 0 5 | for i in range(len(diamantes)): 6 | if diamantes[i]=="<": 7 | diam.append(diamantes[i]) 8 | elif diamantes[i] == ">" and diam: 9 | diam.pop () 10 | diamantes1 += 1 11 | return diamantes1 12 | 13 | 14 | cantidad= int(input("Cantidad de casos de prueba:")) 15 | 16 | for _ in range(cantidad): 17 | diamantes=str(input("Ingresar diamantes:")) 18 | resultado = contardiamantes (diamantes) 19 | print(resultado) 20 | 21 | 22 | 23 | 24 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #6 - Volumen 1 - 100 - Constante de Kaprekar/ValentinoPagani.py: -------------------------------------------------------------------------------- 1 | n = int(input()) 2 | for _ in range(n): 3 | num = input() 4 | cont = 0 5 | while num != '6174': 6 | aux = [''] * 4 7 | mayor = '' 8 | menor = '' 9 | for i in range(4): 10 | aux[i] = num[i] 11 | 12 | aux.sort(reverse=True) 13 | for may in range(4): 14 | mayor += aux[may] 15 | 16 | aux.reverse() 17 | for men in range(4): 18 | menor += aux[men] 19 | 20 | num = str(int(mayor) - int(menor)) 21 | 22 | cont += 1 23 | 24 | print(cont) 25 | -------------------------------------------------------------------------------- /MatiasRomero.py: -------------------------------------------------------------------------------- 1 | resultado = "" 2 | 3 | while True: 4 | dimension = int(input()) 5 | 6 | if dimension == 0: 7 | break 8 | 9 | matriz_identidad = [[1 if i == j else 0 for j in range(dimension)] for i in range(dimension)] 10 | 11 | matriz_usuario_es_identidad = True 12 | 13 | for i in range(dimension): 14 | fila_usuario = list(map(int, input().split())) 15 | 16 | if fila_usuario != matriz_identidad[i]: 17 | matriz_usuario_es_identidad = False 18 | 19 | if matriz_usuario_es_identidad: 20 | resultado += "SI\n" 21 | else: 22 | resultado += "NO\n" 23 | 24 | print(resultado) 25 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #5 - Tiempo del evento/jesusPerochino.py: -------------------------------------------------------------------------------- 1 | dia = input() 2 | w1 = int(dia[-2:]) 3 | hora1 = input() 4 | h1 = int(hora1[0:2]) 5 | m1 = int(hora1[5:7]) 6 | s1 = int(hora1[-2:]) 7 | dia2 = input() 8 | w2 = int(dia2[-2:]) 9 | hora2 = input() 10 | h2 = int(hora2[0:2]) 11 | m2 = int(hora2[5:7]) 12 | s2 = int(hora2[-2:]) 13 | 14 | diap = w2 - w1 15 | hp = h2 - h1 16 | mp = m2 - m1 17 | sp = s2 - s1 18 | 19 | while sp < 0: 20 | mp -=1 21 | sp += 60 22 | while mp < 0: 23 | hp -= 1 24 | mp += 60 25 | while hp < 0: 26 | diap -= 1 27 | hp += 24 28 | 29 | print(diap, "dia(s)") 30 | print(hp, "hora(s)") 31 | print(mp, "minuto(s)") 32 | print(sp, "segundo(s)") -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #4 - Diamantes y Arena/diamantes-arenas.py: -------------------------------------------------------------------------------- 1 | #funcion para contar diamantes 2 | def contar_diamantes(casos, N): 3 | for i in range(N): 4 | aperturas = 0 5 | diamantes = 0 6 | 7 | for caracter in casos[i]: 8 | if caracter == "<": 9 | aperturas += 1 10 | elif caracter == ">" and aperturas > 0: 11 | diamantes += 1 12 | aperturas -= 1 13 | 14 | print(diamantes) 15 | 16 | #leer número de casos de prueba 17 | N = int(input("")) 18 | casos = [input() for i in range(N)] 19 | 20 | #procesar y mostrar los resultados 21 | contar_diamantes(casos, N) 22 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #4 - Diamantes y Arena/TiagoWenger.py: -------------------------------------------------------------------------------- 1 | pruebas=int(input()) 2 | for i in range(pruebas): 3 | dya=input() 4 | bandera=False 5 | abrio=0 6 | dia=0 7 | while bandera==False: 8 | bandera=True 9 | for i in range(len(dya)): 10 | if dya[i]=="<": 11 | abrio=1 12 | indabrio=i 13 | if dya[i]==">" and abrio==1: 14 | dia+=1 15 | abrio=0 16 | bandera=False 17 | dya= dya[0:indabrio] + "D" + dya[indabrio+1:len(dya)] 18 | dya=dya[0:i] + "D" + dya[i:len(dya)] 19 | break 20 | print(dia) 21 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #4 - Diamantes y Arena/jesusPerochino.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | ent = int (input()) 4 | vector=[int for i in range(ent)] 5 | for j in range(ent): 6 | 7 | en = input() 8 | cont1 = 0 9 | 10 | 11 | for i in range(len(en)): 12 | if en[i] == "<": 13 | 14 | x= i 15 | encontrado = True 16 | while encontrado and x < len(en): 17 | 18 | if en[x] == ">": 19 | en = en[0:x] + "." +en[x+1:] 20 | cont1 += 1 21 | encontrado = False 22 | 23 | x += 1 24 | vector[j] = cont1 25 | 26 | 27 | for i in range(ent): 28 | print(vector[i]) -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #4 - Diamantes y Arena/Ejercicio #4 - Santiago Garcia: -------------------------------------------------------------------------------- 1 | def encontradiamantes(subcadena,cont): 2 | bandera=0 3 | cadenanew="" 4 | for i in range(len(subcadena)): 5 | if subcadena[i:2+i]=="<>": 6 | bandera=1 7 | cont+=1 8 | else: 9 | cadenanew+=subcadena[i] 10 | if bandera==0: 11 | return cont 12 | else: return encontradiamantes(cadenanew,cont) 13 | casos=int(input()) 14 | for i in range(casos): 15 | cont=0 16 | cadena=str(input()) 17 | subcadena="" 18 | for j in range(len(cadena)): 19 | if cadena[j]=="<" or cadena[j]==">": 20 | subcadena+=cadena[j] 21 | print(encontradiamantes(subcadena,cont)) 22 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #4 - Diamantes y Arena/JorgeQuipildor#4.py: -------------------------------------------------------------------------------- 1 | def diamantee(cadena): 2 | contador = 0 3 | almacen = [] 4 | 5 | # Recorremos la cadena para encontrar los diamantes la condicion que abre y tiene que cerrar "<>", 6 | #el resto de "." no se tiene en cuenta 7 | for caracter in cadena: 8 | if caracter == "<": 9 | almacen.append(caracter) 10 | elif caracter == ">": 11 | if almacen: 12 | almacen = almacen[:-1] 13 | contador += 1 14 | 15 | return contador 16 | 17 | # Entrada 18 | entrada = int(input()) 19 | for i in range(entrada): 20 | cadena = input() 21 | diamantes = diamantee(cadena) 22 | print(diamantes) 23 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #3 - Cadenas ADN/facundosalera.py: -------------------------------------------------------------------------------- 1 | while True: 2 | nc=int(input()) #num de cadenas 3 | if nc==0: 4 | break 5 | for j in range(nc): #guardar las cadenas en un vector 6 | cadena=str(input()) 7 | if j==0: 8 | v=[""]*nc 9 | v[j]=cadena 10 | for i in range(nc): #recorrer cada cadena 11 | c=nc-1 12 | for z in range(nc): #compararla con las otras cadenas y comprobar si son iguales 13 | if i!=z: 14 | for j in range(len(cadena)): 15 | if v[i][j]!=v[z][j] and v[i][j]!="-" and v[z][j]!="-": 16 | c-=1 17 | break 18 | print(c, end=" ") 19 | print("\n") 20 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #4 - Diamantes y Arena/AbrilCarballo.py: -------------------------------------------------------------------------------- 1 | def main(): 2 | cp = int(input('Casos de prueba: ')) 3 | 4 | for i in range(cp): 5 | expresion = input('Expresion: ') 6 | 7 | diamantes = verificar(expresion) 8 | print(diamantes) 9 | 10 | def verificar(expresion): 11 | cant_diamantes = 0 # Contador de diamantes formados 12 | cant_a = 0 # Contador de '<' 13 | 14 | for i in range(len(expresion)): 15 | if expresion[i] == "<": 16 | cant_a += 1 17 | elif expresion[i] == ">": 18 | if cant_a > 0: # cuento si hay un '<' disponible 19 | cant_diamantes += 1 20 | cant_a -= 1 21 | 22 | return cant_diamantes 23 | 24 | main() -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #4 - Diamantes y Arena/diamantes arena Lautaro Villarreal.py: -------------------------------------------------------------------------------- 1 | intentos = int(input()) 2 | cadenas = [0] * intentos 3 | for i in range(intentos): 4 | cadenas[i] = input() 5 | result = [0] * intentos 6 | cant = 0 7 | for cantidad in range(intentos): 8 | cadena = cadenas[cantidad] 9 | for i in range(len(cadena)): 10 | if cadena[i] == "<": 11 | cadena = cadena[0:i] + "0" + cadena[i+1:len(cadena)] 12 | for j in range(i,len(cadena)): 13 | if cadena[j] == ">": 14 | cadena = cadena[0:j] + "0" + cadena[j+1:len(cadena)] 15 | cant+=1 16 | break 17 | result[cantidad] = cant 18 | cant = 0 19 | for i in result: 20 | print(i) 21 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #0 - Matrices Triangulares/valentinomoreno/ejercicio0/ejercicio0.py: -------------------------------------------------------------------------------- 1 | filas = int(input("Ingrese el número de filas: ")) 2 | 3 | 4 | 5 | matriz = [[0 for y in range(filas)] for x in range(filas)] 6 | for x in range(filas): 7 | for y in range(filas): 8 | matriz[x][y] = int(input(f"Introduzca el valor para la posición ({x+1},{y+1}): ")) 9 | 10 | es_identidad = True # Suponemos que es identidad al inicio 11 | 12 | 13 | for i in range(filas): 14 | for j in range(filas): 15 | if i == j: 16 | if matriz[i][j] != 1: 17 | es_identidad = False 18 | else: 19 | if matriz[i][j] != 0: 20 | es_identidad = False 21 | 22 | 23 | if es_identidad: 24 | print("SI") 25 | else: 26 | print("NO") 27 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #0 - Matrices Triangulares/TiagoWenger.py: -------------------------------------------------------------------------------- 1 | bandera=False 2 | while bandera==False: 3 | filas= int(input()) 4 | if filas!=0 and filas<=50: 5 | matriz=[[0]*filas]*filas 6 | for i in range(filas): 7 | for j in range(filas): 8 | matriz[i][j]=int(input()) 9 | arriba=0 10 | abajo=0 11 | for i in range(filas): 12 | for j in range(filas): 13 | if (i-j)<0: 14 | if matriz[i][j]!=0: 15 | arriba+=1 16 | elif (i-j)>0: 17 | if matriz[i][j]!=0: 18 | abajo+=1 19 | if arriba==0 or abajo==0: 20 | print("SI") 21 | else: 22 | print("NO") 23 | else: 24 | bandera=True -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #9 - Volumen 1 - 151 - Es matriz identidad/paganiValentino.py: -------------------------------------------------------------------------------- 1 | while True: 2 | rango = int(input('')) 3 | if rango == 0: 4 | break 5 | else: 6 | matriz = [[int() for _ in range(rango)] for _ in range(rango)] 7 | for e in range(rango): 8 | elementos = input().split(' ') 9 | for j in range(rango): 10 | matriz[e][j] = int(elementos[j]) 11 | estado = True 12 | for f in range(rango): 13 | for c in range(rango): 14 | if f != c and matriz[f][c] != 0: 15 | estado = False 16 | if f == c and matriz[f][c] != 1: 17 | estado = False 18 | if estado: 19 | print('SI') 20 | else: 21 | print('NO') 22 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #0 - Matrices Triangulares/LeandroDidrig.py: -------------------------------------------------------------------------------- 1 | n = int(input()) 2 | while n!=0: 3 | matriz = [[int(0) for i in range(n)]for j in range(n)] 4 | inferior = 0 5 | superior = 0 6 | for i in range(n): 7 | num = str(input()) 8 | filita = num.split() 9 | for j in range(n): 10 | filita[j] = int(filita[j]) 11 | matriz[i] = filita 12 | for i in range(n): 13 | for j in range(n): 14 | if i!=j and i>j: 15 | if matriz[i][j] != 0 : 16 | inferior =1 17 | for i in range(n): 18 | for j in range(n): 19 | if i!=j and i' and b == 0: 20 | diamantes += 1 21 | vector[a] = '.' 22 | b = 1 23 | print(diamantes) 24 | casos_de_prueba -= 1 -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #8 - Volumen 1 - 148 - Nochevieja/Resolución/Volumen 1 - 148 - Nochevieja.py: -------------------------------------------------------------------------------- 1 | salir = 0 2 | contador = 0 3 | vector_salida = [0] * 100 4 | 5 | while salir == 0: 6 | #INICIALIZACIÓN DE VARIABLES 7 | minutos = 0 8 | horas = 0 9 | 10 | #ENTRADAS 11 | cadena = str(input()) 12 | 13 | if cadena == "00:00": 14 | salir = 1 15 | else: 16 | if cadena[0:2] != "00": 17 | minutos = int(cadena[3 : 5]) 18 | horas = 24 - int(cadena[0 : 2]) 19 | minutos = horas * 60 - minutos 20 | else: 21 | minutos = int(cadena[3:5]) 22 | horas = 24 + int(cadena[0:2]) 23 | minutos = horas*60 - minutos 24 | 25 | vector_salida[contador] = minutos 26 | contador = contador + 1 27 | 28 | for i in range(100): 29 | if vector_salida[i] != 0: 30 | print(vector_salida[i], end = "\n") -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #0 - Matrices Triangulares/lucianogoniat.py: -------------------------------------------------------------------------------- 1 | 2 | f = 10 3 | c = 10 4 | matriz = [[0 for j in range(c)] for i in range(f)] 5 | #Ver como meter numero por numero 6 | filas = 1 7 | 8 | while filas!=0: 9 | filas=int(input()) 10 | if filas == 0: 11 | break 12 | acum1=0 13 | acum2=0 14 | principal=0 15 | for i in range(filas): 16 | for j in range(filas): 17 | matriz[i][j]=str(input()) 18 | 19 | 20 | for x in range(filas): 21 | for i in range(filas): #arriba de la diagonal principal 22 | if xi: 28 | acum2+=matriz[x][i] 29 | 30 | if acum1 ==0 or acum2 ==0 : 31 | print("SI") 32 | else: 33 | print("NO") 34 | 35 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #4 - Diamantes y Arena/AlbaHeredia.py: -------------------------------------------------------------------------------- 1 | Casos=int(input()) 2 | 3 | for i in range(Casos): 4 | Cadena=str(input("Entrada: ")) 5 | 6 | if len(Cadena) <= 1000: 7 | 8 | Ingreso=True 9 | 10 | for j in range(len(Cadena)): 11 | if Cadena[j] != "<" and Cadena[j] != ">" and Cadena[j] != ".": 12 | Ingreso=False 13 | break 14 | 15 | #Contador de diamantes 16 | Diamantes=0 17 | #Contador de picos abiertos 18 | Diamante_izq=0 19 | 20 | if Ingreso: 21 | for k in range(len(Cadena)): 22 | if Cadena[k] == "<": #inicio de diamante 23 | Diamante_izq+=1 24 | 25 | if Cadena[k] == ">" and Diamante_izq > 0: 26 | Diamantes+=1 27 | Diamante_izq-=1 28 | print(Diamantes) 29 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #2 - Buscaminas/TiagoWenger.py: -------------------------------------------------------------------------------- 1 | f=1 2 | c=1 3 | while f!=0 and c!=0: 4 | f=int(input()) 5 | c=int(input()) 6 | if f!=0 and c!=0: 7 | mat = [[" " for _ in range(c)] for _ in range(f)] 8 | for i in range(f): 9 | fila=input() 10 | for j in range(c): 11 | mat[i][j]=fila[j] 12 | tab = [["0" for _ in range(c+2)] for _ in range(f+2)] 13 | for i in range(1,f+1): 14 | for j in range(1,c+1): 15 | tab[i][j]=mat[i-1][j-1] 16 | seisminas=0 17 | for i in range(1,f+1): 18 | for j in range(1,c+1): 19 | cont=0 20 | if tab[i][j]=="-": 21 | for y in range(i-1,i+2): 22 | for x in range(j-1,j+2): 23 | if tab[y][x]=="*": 24 | cont+=1 25 | if cont>=6: 26 | seisminas+=1 27 | print(seisminas) -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #0 - Matrices Triangulares/jesusPerochino.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | salidas = [None] * 50 5 | pos = 0 6 | rango = int(input()) 7 | while rango > 0 and rango <= 50: 8 | 9 | matriz = [None]*rango 10 | for x in range(rango): 11 | linea = input().split() 12 | matriz[x] = linea 13 | 14 | entre = True 15 | salidas[pos] = True # Matriz triangular 16 | if int(matriz[0][1]) == 0: 17 | inicio = 1 18 | for i in range(0,rango-1): 19 | for j in range(inicio,rango-1): 20 | if (int(matriz[i][j]) != 0): 21 | salidas[pos] = False 22 | inicio += 1 23 | entre = False 24 | else: 25 | for i in range(1,rango): 26 | fin = rango - i 27 | for j in range(0,rango-1): 28 | if (int(matriz[i][j]) != 0) : 29 | salidas[pos] = False 30 | entre = False 31 | if entre: 32 | salidas[pos] = False 33 | 34 | 35 | pos += 1 36 | rango = int(input()) 37 | 38 | for i in range(pos): 39 | if salidas[i]: 40 | print("SI") 41 | else: 42 | print("NO") -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #0 - Matrices Triangulares/lautaroRoldan.py: -------------------------------------------------------------------------------- 1 | filas=1 2 | while filas> 0 and filas<50: 3 | filas = int(input()) 4 | columnas = filas 5 | if filas> 0 and filas<50: 6 | matriz = [[int() for ind0 in range(1*columnas)]for ind1 in range(1*filas)] 7 | for i in range(filas): 8 | pal =str(input()) 9 | vec = pal.split(" ") 10 | for m in range(columnas): 11 | matriz[i][m] = int(vec[m]) 12 | 13 | vector = [0]*2 14 | for i in range(filas): 15 | for m in range(columnas): 16 | if matriz[i][m] == 0: 17 | if i>m: 18 | vector[0] = vector[0] + 1 19 | elif i= 6: 24 | respuestas[pos] += 1 25 | pos += 1 26 | en = input().split() 27 | for i in range(pos): 28 | print(respuestas[i]) -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #2 - Buscaminas/pedroRingelmann.py: -------------------------------------------------------------------------------- 1 | dimTablero = str(input()) 2 | dimension= dimTablero.split(" ") 3 | columnas=int(dimension[0]) 4 | filas=int(dimension[1]) 5 | 6 | tablero=[""]*filas 7 | for i in range(filas): 8 | tablero[i]=[""]*columnas 9 | 10 | for i in range(filas): 11 | for j in range(columnas): 12 | tablero[i][j]=str(input()) 13 | 14 | contMinas=0 15 | cont2=0 16 | for i in range(filas): 17 | for j in range(columnas): 18 | if i!=0 and j!=0 and i!=(columnas-1) and j!=(filas-1): 19 | if tablero[i][j]=="-": 20 | for h in range(3): 21 | for z in range(3): 22 | if tablero[((i-1)+h)][((j-1)+z)]=="*": 23 | contMinas+=1 24 | if contMinas>=6: 25 | cont2+=1 26 | contMinas=0 27 | else: 28 | contMinas=0 29 | 30 | for filas in tablero: 31 | print(filas) 32 | 33 | print(cont2) 34 | 35 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #5 - Tiempo del evento/quipildorJorge.py: -------------------------------------------------------------------------------- 1 | #entrada 2 | Dia_inicial=input("Dia: ") 3 | hora_inicial=input().split(":") 4 | dia_final=input("Dia: ") 5 | hora_final=input().split(":") 6 | #convertimos los datos ingresador a segundos 7 | seg_inicio = int(Dia_inicial) * 86400 + int(hora_inicial[0]) * 3600 + int(hora_inicial[1]) * 60 + int(hora_inicial[2]) 8 | seg_fin = int(dia_final) * 86400 + int(hora_final[0]) * 3600 + int(hora_final[1]) * 60 + int(hora_final[2]) 9 | #calculamos la diferencia de horas y minutos 10 | dif_seg = seg_fin - seg_inicio 11 | dias = dif_seg // 86400 12 | dif_seg = dif_seg % 86400 13 | horas = dif_seg // 3600 14 | dif_seg = dif_seg % 3600 15 | min = dif_seg // 60 16 | seg = dif_seg % 60 17 | #salida 18 | print(dias,"dias(s)") 19 | print(horas,"horas(s)") 20 | print(min,"minutos(s)") 21 | print(seg,"segundo(s)") 22 | 23 | #se convierte los datos a segundos y luego convertimos a minutos ,horas y dias. para manejar con mayor facilidad y evitar errores en el conteo de los datos 24 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #0 - Matrices Triangulares/victoriaPetry.py: -------------------------------------------------------------------------------- 1 | ingreso=str(input()) 2 | if int(ingreso)>0 and int(ingreso)<50: 3 | matriz=[[str()for ind0 in range(1*(int(ingreso)))]for ind1 in range (1*(int(ingreso)))] 4 | for i in range(int(ingreso)): 5 | v=str(input()) 6 | for j in range(len(v)): 7 | matriz[i][j]=v[j] 8 | 9 | cs=ci=0 10 | #condicion 11 | for i in range(int(ingreso)): 12 | for j in range(int(ingreso)): 13 | if i>j and i!=j: 14 | if matriz[i][j]==0: 15 | ci+=1 16 | else: 17 | if matriz[i][j]==0: 18 | cs+=1 19 | if ci%3==0: 20 | print("es triangular") 21 | elif ci%3!=0: 22 | print("no es triangular") 23 | elif cs%3==0: 24 | print("es triangular") 25 | elif cs%3!=0: 26 | print("no es triangular") 27 | 28 | 29 | #imprimir matriz 30 | """ for i in range(int(ingreso)): 31 | for j in range(int(ingreso)): 32 | print(matriz[i][j],end=" ") 33 | print(" ") 34 | """ 35 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #9 - Volumen 1 - 151 - Es matriz identidad/SantiagoGarcia.py: -------------------------------------------------------------------------------- 1 | dimension=int(input()) 2 | def carga_matriz(tamaño): 3 | matriz = [[0 for c in range(tamaño)]for f in range(tamaño)] 4 | for filas in range(tamaño): 5 | palabra = input() 6 | if palabra[-1] == " ": palabra = palabra[0:len(palabra)-1] 7 | numero,col = "",0 8 | for i in range(len(palabra)): 9 | if palabra[i] != " ": numero+=palabra[i] 10 | else: 11 | matriz[filas][col] = int(numero) 12 | col+=1 13 | numero = "" 14 | matriz[filas][col] = int(numero) 15 | return matriz 16 | while dimension!=0: 17 | bandera=0 18 | matriz=carga_matriz(dimension) 19 | for i in range(dimension): 20 | for j in range(dimension): 21 | if matriz[i][i]!=1 or (j>i and (matriz[i][j]!=0 or matriz[j][i]!=0)): 22 | bandera=1 23 | if bandera==0: print("Si") 24 | else: print("No") 25 | dimension=int(input()) 26 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #2 - Buscaminas/mateoMaggi.py: -------------------------------------------------------------------------------- 1 | tablero = str(input()) 2 | vector_tab = tablero.split() 3 | ancho = int(vector_tab[0]) 4 | alto = int(vector_tab[1]) 5 | minas = int(0) 6 | celdas_vacias = int(0) 7 | matriz = [[str() for i in range(ancho)] for k in range(alto)] 8 | 9 | if ancho != 0 and alto != 0: 10 | for i in range(alto): # filas 11 | pal = str(input()).split() 12 | for k in range(ancho): # columnas 13 | matriz[i][k] = pal[k] 14 | i = int(0) 15 | k = int(0) 16 | for i in range(1,alto - 1): #0,1,2,3,4 17 | for k in range(1, ancho - 1): 18 | if matriz[i][k] == '-': 19 | for a in range(i - 1, i + 2): 20 | for b in range(k - 1, k + 2): 21 | if matriz[a][b] == "*": 22 | minas += 1 23 | if minas >= 6: 24 | celdas_vacias += 1 25 | minas = int(0) 26 | print(celdas_vacias) 27 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #3 - Cadenas ADN/Ejercicio #3 - Santiago Garcia.py: -------------------------------------------------------------------------------- 1 | def compdecadenas(numero,vector): 2 | vector2=[int]*numero 3 | for i in range(numero): 4 | cont=0 5 | subcadena=vector[i] 6 | for j in range(len(subcadena)): 7 | if j!=i: 8 | if jmax: 29 | max=c 30 | c=0 31 | else: 32 | c+=1 33 | #distancia extremo derecho 34 | c=c-1 35 | if c>max: 36 | max=c 37 | print(max) 38 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #5 - Tiempo del evento/RoldanLautaro.py: -------------------------------------------------------------------------------- 1 | 2 | vec = [str] 3 | 4 | for i in range(2): 5 | dias = str(input()) 6 | horas = str(input()) 7 | vec.append(dias) 8 | vec.append(horas) 9 | 10 | 11 | f1 = vec[1].split(" ") 12 | h1 = vec[2].split(":") 13 | 14 | 15 | f2 = vec[3].split(" ") 16 | h2 = vec[4].split(":") 17 | 18 | dia1 = int(f1[1]) 19 | horas = int(h1[0]) 20 | minutos = int(h1[1]) 21 | segundos = int(h1[2]) 22 | 23 | dia2 = int(f2[1]) 24 | horas2 = int(h2[0]) 25 | minutos2 = int(h2[1]) 26 | segundos2 = int(h2[2]) 27 | 28 | diasT = dia2 - dia1 29 | 30 | segundosT = segundos2 - segundos 31 | 32 | if segundosT < 0: 33 | segundosT = 60 + segundosT 34 | minutos2 = minutos2 - 1 35 | 36 | minutosT = minutos2 - minutos 37 | 38 | if minutosT < 0: 39 | minutosT = 60 + minutosT 40 | horas2 = horas2 - 1 41 | 42 | horasT = horas2 - horas 43 | 44 | if horasT < 0: 45 | horasT = 24 + horasT 46 | diasT = diasT - 1 47 | 48 | print(f"{diasT} dia(s)") 49 | print(f"{horasT} hora(s)") 50 | print(f"{minutosT} minuto(s)") 51 | print(f"{segundosT} segundo(s)") -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #9 - Volumen 1 - 151 - Es matriz identidad/Lucianogoniat.py: -------------------------------------------------------------------------------- 1 | f = 10 2 | c = 10 3 | matriz = [[0 for j in range(c)] for i in range(f)] 4 | 5 | filas = 1 6 | while filas!=0: 7 | filas=int(input()) 8 | if filas == 0: 9 | break 10 | acum1=0 11 | acum2=0 12 | principal=0 13 | for i in range(filas): 14 | for j in range(filas): 15 | matriz[i][j]=int(input()) 16 | 17 | for n in range(filas): 18 | if matriz[n][n] == 1: 19 | principal+=matriz[n][n] 20 | else: 21 | break 22 | 23 | for x in range(filas): 24 | for i in range(filas): #arriba de la diagonal principal 25 | if xi: 31 | acum2+=matriz[x][i] 32 | 33 | if acum1 ==0 and acum2 ==0 and principal == 3: 34 | print("SI") 35 | else: 36 | print("NO") 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #0 - Matrices Triangulares/Ejercicio #0 - Marcos_Elizondo.py: -------------------------------------------------------------------------------- 1 | numero=1 2 | while numero != 0: 3 | triangular_superior=1 4 | triangular_inferior=1 5 | numero=int(input()) 6 | Matriz=[[int(0) for fila in range(numero)]for columna in range (numero)] 7 | for i in range (numero): 8 | j2=0 9 | num=input("") 10 | for j in range((numero)+(numero-1)): 11 | if num[j:j+1] != ' ': 12 | Matriz[i][j2]=int(num[j:j+1]) 13 | j2+=1 14 | 15 | #for i in range (numero): 16 | # for j in range (numero): 17 | # Matriz[i][j]=int(input()) 18 | for fila in range (numero): 19 | for columna in range (numero): 20 | if fila != columna: 21 | if filacolumna and Matriz[fila][columna]!=0: 24 | triangular_inferior=0 25 | if triangular_inferior == 1 or triangular_superior == 1: 26 | print("SI") 27 | else: 28 | print("NO") -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #4 - Diamantes y Arena/lucasPonce.py: -------------------------------------------------------------------------------- 1 | def contar_diamantes(entrada): 2 | contador = 0 # Contador para verificar los diamantes "<>" encontrados 3 | diamantes = 0 # Contador para sumar la cantidad de diamantes "<>" encontrados 4 | 5 | for caracter in entrada: 6 | if caracter == "<": 7 | contador += 1 # Si se detecta un "<" (que sería el 'inicio' de un diamante), sumamos 1 8 | # Si se detecta un ">" ('cierre' de un diamante), y existe anteriormente un "<" ('inicio' de un diamante), restamos -1 9 | elif caracter == ">" and contador > 0: 10 | contador -= 1 # Reestablecemos la variable en 0 11 | diamantes += 1 # Indicamos que se encontró un (1) diamante 12 | 13 | return diamantes 14 | 15 | N = int(input()) # Leemos la cantidad de casos de prueba 16 | resultado = "" # Creamos una cadena vacía para acumular los resultados 17 | 18 | for i in range(N): 19 | entrada = input() 20 | diamantes = contar_diamantes(entrada) # Llamamos a la función 21 | resultado += str(diamantes) + "\n" # Acumulamos los resultados en la cadena 22 | 23 | print(resultado) -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #4 - Diamantes y Arena/gianeRocha.py: -------------------------------------------------------------------------------- 1 | def comprobar(vector): 2 | cantidad=len(vector) 3 | contador1=0 4 | contador2=0 5 | cont3=0 #<<..>> 6 | vector2=[0]*cantidad 7 | 8 | for i in range (0,cantidad,1): 9 | cadena=vector[i] 10 | for j in range(0,(len(cadena)),1): 11 | if cadena[j]=="<": 12 | contador1=contador1+1 13 | elif cadena[j] ==">": 14 | contador2=contador2+1 15 | if contador1 == contador2: 16 | cont3=+1 17 | elif contador1 > contador2: 18 | cont3 = contador2 19 | if contador2 > contador1: 20 | cont3 = contador1 21 | contador1=0 22 | contador2=0 23 | vector2[i]=cont3 24 | cont3= 0 25 | return vector2 26 | 27 | 28 | prueba=int(input()) 29 | contador1=0 30 | contador2=0 31 | cont3=0 32 | vector=[""]*prueba 33 | for i in range(0,prueba,1): 34 | linea=(str(input("ingresar linea:"))) 35 | vector[i]=linea 36 | 37 | 38 | resultado=comprobar(vector) 39 | 40 | 41 | for i in range (0,(len(resultado)),1): 42 | print(resultado[i]) -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #9 - Volumen 1 - 151 - Es matriz identidad/facundosalera.py: -------------------------------------------------------------------------------- 1 | while True: 2 | f=int(input()) 3 | if f==0: 4 | break 5 | m=[[0]*f for i in range(f)] 6 | t=True 7 | for i in range(f): 8 | #contador columna 9 | c=0 10 | #indice donde comienza cada numero 11 | ui=0 12 | #ingresa la fila como cadena 13 | fila=str(input())+" " 14 | #recorremos la cadena 15 | for z in range(len(fila)): 16 | #guardamos el numero cada vez que encontramos un espacio 17 | if fila[z]==" ": 18 | m[i][c]=int(fila[ui:z]) 19 | #actualizamos el ultimo indice y contador 20 | ui=z+1 21 | c+=1 22 | for i in range(f): 23 | for z in range(f): 24 | #comprobamos diagonal principal 25 | if i==z: 26 | if m[i][z]!=1: 27 | t=False 28 | #comprobamos resto de la matriz 29 | else: 30 | if m[i][z]!=0: 31 | t=False 32 | if t==True: 33 | print("SI") 34 | else: 35 | print("NO") 36 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #0 - Matrices Triangulares/mateoMaggi.py: -------------------------------------------------------------------------------- 1 | entrada = int(input()) 2 | matriz = [[int() for i in range(entrada)] for k in range(entrada)] 3 | elemento_cero = int(0) 4 | pal = [] 5 | es_triangular_sup = int(1) 6 | es_triangular_inf = int(1) 7 | 8 | for i in range(entrada): # filas 9 | pal = str(input()).split(" ") 10 | for k in range(entrada): # columnas 11 | matriz[i][k] = int(pal[k]) 12 | 13 | for i in range(len(matriz)): # t sup 14 | for k in range(i + 1, len(matriz)): 15 | if matriz[i][k] != 0: 16 | es_triangular_sup = int(0) 17 | 18 | for i in range(len(matriz)): # t inf 19 | for k in range(0, i): 20 | if matriz[i][k] != 0: 21 | es_triangular_inf = int(0) 22 | 23 | if es_triangular_inf and es_triangular_sup: 24 | print("Es triangular sup y inf") 25 | else: 26 | if es_triangular_sup: 27 | print("Es triangular sup") 28 | if es_triangular_inf: 29 | print("Es triangular inf") 30 | if es_triangular_inf == 0 and es_triangular_sup == 0: 31 | print("No es triangular") 32 | 33 | print(matriz) 34 | 35 | # i, k 36 | # 00 01 02 37 | # 10 11 12 38 | # 20 21 22 39 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #2 - Buscaminas/victoriaPetry.py: -------------------------------------------------------------------------------- 1 | #entrada de datos linea por linea 2 | ingreso=str(input()) 3 | #separo por espacios para saber las columnas y filas 4 | ingreso=ingreso.split(" ") 5 | matriz=[[str()for ind0 in range(1*(int(ingreso[0])))]for ind1 in range (1*(int(ingreso[1])))] 6 | for i in range(int(ingreso[1])): 7 | v=str(input()) 8 | for j in range(len(v)): 9 | matriz[i][j]=v[j] 10 | #vector ingreso tiene las dimensiones de la matriz 11 | filas=int(ingreso[1]) 12 | columnas=int(ingreso[0]) 13 | cont=0 14 | c=0 15 | #busco el -, y con un contador se buscan cuantos * hay 16 | for i in range(int(ingreso[1])): 17 | for j in range(int(ingreso[0])): 18 | if i!=0 and j!=0 and i!=(filas-1) and j!=(columnas-1): 19 | if matriz[i][j]=="-": 20 | for a in range(3): 21 | for b in range(3): 22 | if matriz[(i-1)+a][(j-1)+b]=="*": 23 | cont+=1 24 | if cont==6: 25 | c+=1 26 | cont=0 27 | else: 28 | cont=0 29 | print(c) 30 | #salida sera cuando el contador sea igual a seis, es decir que se encontraron 6 (*). -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #4 - Diamantes y Arena/Resolucion/resoluciónProfes.py: -------------------------------------------------------------------------------- 1 | """ 2 | FUNCIONES 3 | """ 4 | def contarDiamantes(cadena): 5 | contador = 0 6 | bandera = True 7 | 8 | while bandera == True: 9 | bandera = False 10 | b1 = False 11 | 12 | for i in range(len(cadena)): 13 | if cadena[i] == "<": 14 | b1 = True 15 | indiceA = i 16 | 17 | if cadena[i] == ">" and b1 == True: 18 | contador = contador + 1 19 | bandera = True 20 | b1 = False 21 | 22 | #Signo cierre 23 | cadena = cadena[0 : i] + "0" + cadena[i+1 : len(cadena)] 24 | 25 | cadena = cadena[0 : indiceA] + "0" + cadena[indiceA+1 : len(cadena)] 26 | 27 | break 28 | 29 | return contador 30 | 31 | """ 32 | MAIN 33 | """ 34 | 35 | #INICIALIZACIÓN DE VARIABLES 36 | casosUso = int(input()) 37 | vectorResultado = [0] * casosUso 38 | 39 | #ENTRADAS Y PROCESOS 40 | for i in range(casosUso): 41 | entrada = str(input()) 42 | vectorResultado[i] = contarDiamantes(entrada) 43 | 44 | #SALIDAS 45 | for i in range(casosUso): 46 | print(vectorResultado[i]) -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #9 - Volumen 1 - 151 - Es matriz identidad/matriz.py: -------------------------------------------------------------------------------- 1 | #problema de matrices 09 2 | 3 | resultados = [] * 10 #vector para almacenar los resultados 4 | 5 | def es_matriz_identidad(matriz, n): 6 | for i in range(n): 7 | for j in range(n): 8 | if (i == j and matriz[i][j] != 1) or (i != j and matriz[i][j] != 0): 9 | return False 10 | return True 11 | 12 | #lectura de la entrada 13 | while True: 14 | n = int(input()) 15 | if n == 0: 16 | break 17 | 18 | matriz = [[0] * n for i in range(n)] 19 | 20 | for i in range(n): 21 | fila = input() 22 | num = "" 23 | col = 0 24 | for caracter in fila: 25 | if caracter != " ": 26 | num += caracter 27 | else: 28 | if num: 29 | matriz[i][col] = int(num) 30 | num = "" 31 | col += 1 32 | if num: 33 | matriz[i][col] = int(num) 34 | 35 | #verificamos si es matriz identidad 36 | if es_matriz_identidad(matriz, n): 37 | resultados += ["SI"] 38 | else: 39 | resultados += ["NO"] 40 | 41 | #imprimimos todos los resultados juntos 42 | for resultado in resultados: 43 | print(resultado) -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #0 - Matrices Triangulares/pedroRingelmann.py: -------------------------------------------------------------------------------- 1 | def triangular(matriz, cantFilas): 2 | for i in range(cantFilas): 3 | for j in range(cantFilas): 4 | if i > j and matriz[i][j] != 0: 5 | return False 6 | if i < j and matriz[i][j] != 0: 7 | return False 8 | return True 9 | 10 | cantFilas = int(input()) 11 | 12 | if 0 < cantFilas < 50: 13 | matriz = [[0] * cantFilas for i in range(cantFilas)] 14 | 15 | for i in range(cantFilas): 16 | for j in range(cantFilas): 17 | matriz[i][j] = int(input()) 18 | 19 | for filas in matriz: 20 | print(filas) 21 | 22 | if triangular(matriz, cantFilas): 23 | print("SI") 24 | else: 25 | print("NO") 26 | 27 | 28 | 29 | 30 | """ 31 | cantFilas=int(input()) 32 | cantdeCeros=0 33 | if cantFilas>0 and cantFilas<50: 34 | matriz=[0]*cantFilas 35 | for i in range(cantFilas): 36 | matriz[i]=[0]*cantFilas 37 | 38 | for i in range(cantFilas): 39 | for j in range(cantFilas): 40 | matriz[i][j]=int(input()) 41 | if matriz[i][j]: 42 | cantdeCeros+=1 43 | 44 | for filas in matriz: 45 | print(filas) 46 | 47 | 48 | if (i != j and j > i): 49 | print("SI") 50 | 51 | else: 52 | print("NO") 53 | """ -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #5 - Tiempo del evento/ValentinoPagani.py: -------------------------------------------------------------------------------- 1 | inicio = input() 2 | inicio_horario = input().split(':') 3 | fin = input() 4 | fin_horario = input().split(':') 5 | dia_i = int(inicio[4:]) 6 | hora_i = inicio_horario[0] 7 | min_i = inicio_horario[1] 8 | seg_i = inicio_horario[2] 9 | dia_f = int(fin[4:]) 10 | hora_f = fin_horario[0] 11 | min_f = fin_horario[1] 12 | seg_f = fin_horario[2] 13 | if hora_i[0] == '0': 14 | hora_i = hora_i[1] 15 | if hora_f[0] == '0': 16 | hora_f = hora_f[1] 17 | if min_i[0] == '0': 18 | min_i = min_i[1] 19 | if min_f[0] == '0': 20 | min_f = min_f[1] 21 | if seg_i[0] == '0': 22 | seg_i = seg_i[1] 23 | if min_f[0] == '0': 24 | seg_f = seg_f[1] 25 | hora_i = int(hora_i) 26 | min_i = int(min_i) 27 | seg_i = int(seg_i) 28 | hora_f = int(hora_f) 29 | min_f = int(min_f) 30 | seg_f = int(seg_f) 31 | 32 | dias_t = dia_f - dia_i 33 | horas_t = hora_f - hora_i 34 | min_t = min_f - min_i 35 | seg_t = seg_f - seg_i 36 | 37 | if hora_i > hora_f: 38 | horas_t = 24 + horas_t 39 | dias_t -= 1 40 | if min_i > min_f: 41 | min_t = 60 + min_t 42 | horas_t -= 1 43 | if seg_i > seg_f: 44 | seg_t = 60 + seg_t 45 | min_t -= 1 46 | 47 | print(dias_t, 'dia (s)') 48 | print(horas_t, 'hora (s)') 49 | print(min_t, 'minuto (s)') 50 | print(seg_t, 'segundo (s)') 51 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #3 - Cadenas ADN/TiagoWenger.py: -------------------------------------------------------------------------------- 1 | adn=1 2 | while adn!=0 and adn<40000: 3 | adn=int(input()) 4 | if adn!=0 and adn<40000: 5 | vec=[" "]*adn 6 | vec[0]=input() 7 | long=len(vec[0]) 8 | if long<50: 9 | for i in range(1,adn): 10 | vec[i]=input() 11 | if long!=len(vec[i]): 12 | print("Escribiste una ADN con diferente longitud") 13 | break 14 | matriz = [[' ' for _ in range(long)] for _ in range(adn)] 15 | for i in range(adn): 16 | cadena = vec[i] 17 | for j in range(long): 18 | matriz[i][j] = cadena[j] 19 | igual=[0]*adn 20 | for i in range(adn): 21 | cont=-1 22 | for x in range(adn): 23 | resul=True 24 | for j in range(long): 25 | if matriz[x][j]!="-" and matriz[x][j]!=matriz[i][j] and matriz[i][j]!="-": 26 | resul=False 27 | break 28 | if resul==True: 29 | cont+=1 30 | igual[i]=cont 31 | for i in range(adn): 32 | print(igual[i], end=" ") 33 | 34 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #2 - Buscaminas/gianellaRocha.py: -------------------------------------------------------------------------------- 1 | entrada1=1 2 | entrada=1 3 | c=0 4 | elemento=0 5 | while entrada !=0 and entrada1 != 0: 6 | entrada = int(input("columna:")) #columnas 7 | entrada1 = int(input("filas:")) #filas 8 | if entrada and entrada1 != 0: 9 | matriz = [[int() for ind0 in range(entrada)] for ind1 in range(entrada1)] 10 | 11 | for i in range(entrada1): 12 | linea = str(input()) 13 | for k in range(entrada): 14 | matriz[i][k] = linea[k] 15 | for i in range (1,entrada1-1,1):#fila 16 | for k in range(1,entrada-1,1):#columna 17 | if matriz[i][k]=="-": 18 | if matriz[i-1] [k-1]=="*": 19 | c+=1 20 | if matriz[i-1][k]=="*": 21 | c+=1 22 | if matriz[i-1][k+1]=="*": 23 | c+=1 24 | if matriz[i][k+1]=="*": 25 | c+=1 26 | if matriz[i+1][k+1]=="*": 27 | c+=1 28 | if matriz[i+1][k]=="*": 29 | c+=1 30 | if matriz[i+1][k-1]=="*": 31 | c+=1 32 | if matriz [i][k-1]=="*": 33 | c+=1 34 | if c>=6: 35 | elemento+=1 36 | c=0 37 | print("hay", elemento,"elementos con por lo menos 6 minas alrededor") -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #0 - Matrices Triangulares/EstebanAballay.py: -------------------------------------------------------------------------------- 1 | """ a = 5 2 | nombre = "Juan" 3 | print(f"Mi nombre es {nombre} y tengo {a} años", a) 4 | """ 5 | # Matriz 6 | """ columnas = 10 7 | filas = 10 8 | matriz = [[int() for i in range(columnas)]for j in range(filas)] 9 | 10 | for i in range(filas): 11 | for j in range(columnas): 12 | matriz[i][j] = str(i) + str(j) 13 | print(matriz[i][j],end=" ") 14 | print(" ") """ 15 | def boolean(cadena): 16 | if cadena == "SI": 17 | return True 18 | else: 19 | return False 20 | 21 | elementos = str 22 | dimension = int(input("Ingrese la dimension de la matriz cuadrada: ")) 23 | solucion1 = "SI" 24 | solucion2 = "SI" 25 | matriz = [[int for i in range(dimension)]for j in range(dimension)] 26 | 27 | for i in range(dimension): 28 | elementos = input("Ingrese los elementos de cada fila(la cantidad de elementos=dimensión): ") 29 | for j in range(dimension): 30 | matriz[i][j] = elementos[j] 31 | 32 | for i in range(dimension): 33 | for j in range(dimension): 34 | if i > j and (matriz[i][j] != str(0)): 35 | solucion1 = "NO" 36 | 37 | for i in range(dimension): 38 | for j in range(dimension): 39 | if i < j and (matriz[i][j] != str(0)): 40 | solucion2 = "NO" 41 | 42 | 43 | solution = boolean(solucion1) or boolean(solucion2) 44 | 45 | if solution == True: 46 | print("SI") 47 | else: 48 | print("NO") 49 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #2 - Buscaminas/roldanLautaro.py: -------------------------------------------------------------------------------- 1 | filas = 1 2 | columnas = 1 3 | 4 | while columnas!=0 and filas!=0: 5 | FC = str(input()) 6 | AF = FC.split(" ") 7 | filas = int(AF[1]) 8 | columnas = int(AF[0]) 9 | matriz = [[str() for ind0 in range(1*columnas)]for ind1 in range(1*filas)] 10 | 11 | if columnas!=0 and filas!=0 : 12 | 13 | for i in range(filas): 14 | carga = str(input()) 15 | for h in range(len(carga)): 16 | matriz[i][h]=carga[h] 17 | 18 | print(" ") 19 | 20 | for i in range(filas): 21 | for h in range(columnas): 22 | print(matriz[i][h],end="") 23 | print(" ") 24 | 25 | cont2 = 0 26 | cont = 0 27 | 28 | for i in range(filas): 29 | for h in range(columnas): 30 | if h != 0 and h != columnas-1 and i != 0 and i != filas-1: 31 | if matriz[i][h] == "-": 32 | for j in range(3): 33 | for z in range(3): 34 | if matriz[((i-1)+j)][((h-1)+z)]== "*": 35 | cont = cont+1 36 | 37 | if cont >= 6: 38 | cont2 = cont2+1 39 | cont = 0 40 | else: 41 | cont = 0 42 | 43 | print(cont2) 44 | 45 | 46 | 47 | 48 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #9 - Volumen 1 - 151 - Es matriz identidad/lucasPonce.py: -------------------------------------------------------------------------------- 1 | resultado = "" # Cadena vacía para acumular los resultados 2 | 3 | while True: 4 | dimension = int(input()) 5 | 6 | if dimension == 0: # Si la dimensión es 0, finaliza el programa 7 | break 8 | 9 | # Creamos la matriz identidad 10 | matriz_identidad = [[1 if i == j else 0 for j in range(dimension)] for i in range(dimension)] 11 | 12 | matriz_usuario = True # "Bandera/Flag" para verificar si la matriz es igual a la matriz identidad 13 | 14 | for i in range(dimension): 15 | fila = input() # Leemos la fila ingresada por el usuario 16 | contador, numero = 0, "" 17 | 18 | # Procesamos la fila y comparamos con la matriz identidad 19 | for caracter in fila: 20 | if caracter == " ": 21 | if numero: 22 | if int(numero) != matriz_identidad[i][contador]: 23 | matriz_usuario = False 24 | contador += 1 25 | numero = "" 26 | else: 27 | numero += caracter 28 | 29 | if numero: # Comparamos el último número de la fila 30 | if int(numero) != matriz_identidad[i][contador]: 31 | matriz_usuario = False 32 | 33 | # Acumulamos los resultados en la primer cadena vacía 34 | if matriz_usuario: 35 | resultado += "SI\n" 36 | else: 37 | resultado += "NO\n" 38 | 39 | print(resultado) -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #9 - Volumen 1 - 151 - Es matriz identidad/LeandroDidrig.py: -------------------------------------------------------------------------------- 1 | def separar_numeros(numeros,n): 2 | e = [int(0)]*100 3 | numbers = [int(0)]*n 4 | f = 1 5 | for i in range(len(numeros)): 6 | if (numeros[i]==' '): 7 | e[f] = i 8 | f += 1 9 | e[f] = len(numeros) 10 | b = 0 11 | a = 1 12 | for i in range(f): 13 | if i == 0: 14 | numbers[i] = int(numeros[e[b]:e[a]]) 15 | a += 1 16 | b += 1 17 | else: 18 | numbers[i] = int(numeros[e[b]+1:e[a]]) 19 | a += 1 20 | b += 1 21 | return numbers 22 | 23 | n = int(input()) 24 | VoF = [str(0)]*1000 25 | indice = 0 26 | k = 0 27 | while n!=0: 28 | matriz = [[int(0) for i in range(n)]for j in range(n)] 29 | identidad = 0 30 | for i in range(n): 31 | num = str(input()) 32 | filita = separar_numeros(num,n) 33 | for j in range(n): 34 | filita[j] = int(filita[j]) 35 | matriz[i] = filita 36 | for i in range(n): 37 | for j in range(n): 38 | if i!=j: 39 | if matriz[i][j] != 0 : 40 | identidad = 1 41 | if i==j: 42 | if matriz[i][j] != 1: 43 | identidad = 1 44 | if identidad == 1: 45 | VoF[indice] = "NO" 46 | indice += 1 47 | else: 48 | VoF[indice] = "SI" 49 | indice += 1 50 | k += 1 51 | n = int(input()) 52 | for i in range(k): 53 | print(VoF[i]) 54 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #2 - Buscaminas/Resolucion/resolucionProfes.py: -------------------------------------------------------------------------------- 1 | def separarCadena (cadena): 2 | vector = [""] * len(cadena) 3 | for i in range(len(cadena)): 4 | vector[i] = cadena[i] 5 | return vector 6 | 7 | def contarMinasAlrededor(y, tablero): 8 | contador = 0 9 | for i in range(y+1): 10 | for j in range(y+1): 11 | if tablero[i][j] == '*': 12 | contador += 1 13 | return contador 14 | 15 | def celdasVacias(columnas, filas, tablero): 16 | contador = 0 17 | 18 | for y in range(1, filas-1): 19 | for x in range(1, columnas-1): 20 | if tablero[y][x] == '-': 21 | minas_alrededor = contarMinasAlrededor(y, tablero) 22 | if minas_alrededor >= 6: 23 | contador += 1 24 | 25 | return contador 26 | 27 | vectorResultados = [0] * 100 28 | a = 0 29 | while True: 30 | entrada = input() 31 | ancho = int(entrada[0]) # Columnas 32 | alto = int(entrada[2]) # Filas 33 | 34 | if ancho == 0 and alto == 0: 35 | break # Fin de la entrada 36 | 37 | tablero = [[str() for ind0 in range(ancho)] for ind1 in range(alto)] 38 | for i in range(alto): 39 | linea = str(input()) 40 | linea = separarCadena(linea) 41 | for k in range(ancho): 42 | tablero[i][k] = linea[k] 43 | 44 | vectorResultados[a] = celdasVacias(ancho, alto, tablero) 45 | a += 1 46 | 47 | for i in range(a): 48 | print(vectorResultados[i]) 49 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #3 - Cadenas ADN/lautaroRoldan.py: -------------------------------------------------------------------------------- 1 | indice = int(input()) 2 | vec = [] 3 | 4 | def cond(vec,vec2): 5 | for j in range(len(vec)): 6 | if vec[j] == vec2[j] or vec[j] == "-" or vec2[j] == "-": 7 | return True 8 | 9 | def cond2(vec,vec2): 10 | comp = "-" 11 | letra=["A","T","G","C"] 12 | cond = True 13 | for i in range(len(letra)): 14 | if (str(letra[i]) in vec) == True: 15 | comp = letra[i] 16 | break 17 | if comp != "-": 18 | for h in range(len(letra)): 19 | if comp != letra[h]: 20 | if (str(letra[h]) in vec2) == True: 21 | cond = False 22 | return cond 23 | 24 | 25 | if indice != 1: 26 | for i in range(indice): 27 | pal = str(input()) 28 | prueba=[" "]*len(pal) 29 | for m in range(len(pal)): 30 | prueba[m] = pal[m] 31 | vec.append(prueba) 32 | 33 | res=[0]*indice 34 | cont = 0 35 | 36 | for i in range(len(vec)): 37 | for m in range(len(vec)): 38 | if i != m: 39 | cod1 = cond(vec[i],vec[m]) 40 | cod2 = cond2(vec[i],vec[m]) 41 | if cod1 == True and cod2 == True: 42 | res[i] = res[i] + 1 43 | 44 | else: 45 | for i in range(indice): 46 | pal = str(input()) 47 | prueba=[" "]*len(pal) 48 | for m in range(len(pal)): 49 | prueba[m] = pal[m] 50 | vec.append(prueba) 51 | res = 0 52 | 53 | print(res) -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #5 - Tiempo del evento/resolucionProfes.py: -------------------------------------------------------------------------------- 1 | entradaDia1 = input() 2 | entradaHorario1 = input() 3 | entradaDia2 = input() 4 | entradaHorario2 = input() 5 | 6 | #Extracción de días 7 | def extraccionDias(cadena): 8 | for i in range(len(cadena)): 9 | if cadena[i] == " ": 10 | return int(cadena[i+1 : ]) 11 | 12 | #Extracción de horas 13 | def extraccionHoras(cadena): 14 | return int(cadena[0:2]) 15 | 16 | #Extracción de minutos 17 | def extraccionMinutos(cadena): 18 | return int(cadena[5:7]) 19 | 20 | #Extracción segundos 21 | def extraccionSegundos(cadena): 22 | return int(cadena[10:]) 23 | 24 | dia1 = extraccionDias(entradaDia1) 25 | dia2 = extraccionDias(entradaDia2) 26 | hora1 = extraccionHoras(entradaHorario1) 27 | hora2 = extraccionHoras(entradaHorario2) 28 | minutos1 = extraccionMinutos(entradaHorario1) 29 | minutos2 = extraccionMinutos(entradaHorario2) 30 | segundos1 = extraccionSegundos(entradaHorario1) 31 | segundos2 = extraccionSegundos(entradaHorario2) 32 | 33 | total1 = dia1 * 86400 + hora1 * 3600 + minutos1 * 60 + segundos1 34 | total2 = dia2 * 86400 + hora2 * 3600 + minutos2 * 60 + segundos2 35 | 36 | diferencia = total2 - total1 37 | 38 | dias = diferencia // 86400 39 | diferencia = diferencia - (dias * 86400) 40 | 41 | horas = diferencia // 3600 42 | diferencia = diferencia - (horas * 3600) 43 | 44 | minutos = diferencia // 60 45 | diferencia = diferencia - (minutos * 60) 46 | 47 | segundos = diferencia 48 | 49 | print(str(dias) + " dia(s)") 50 | print(str(horas) + " hora(s)") 51 | print(str(minutos) + " minuto(s)") 52 | print(str(segundos) + " segundo(s)") -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #9 - Volumen 1 - 151 - Es matriz identidad/joaquinrojas.py: -------------------------------------------------------------------------------- 1 | def cuadradaMatriz(arr): 2 | matriz = [[0 for i in range(arr)] for j in range(arr) ] 3 | return matriz 4 | 5 | def mostrarMatriz(matriz,arr): 6 | for i in range(arr): 7 | for j in range(arr): 8 | print(matriz[i][j],end=" ") 9 | print(" ") 10 | 11 | def rellenarMatriz(matriz,arr): 12 | for i in range(arr): 13 | for j in range(arr): 14 | matriz[i][j]=int(input()) 15 | return matriz 16 | 17 | def verificadorDiagonal(matriz,arr): 18 | flag = True 19 | # parte superior 20 | for i in range(arr): 21 | for j in range(arr): 22 | if i > j and matriz[i][j] != 0: 23 | flag = False 24 | break 25 | # parte inferior 26 | for i in range(arr): 27 | for j in range(arr): 28 | if i < j and matriz[i][j] != 0: 29 | flag = False 30 | break 31 | # diagonal principal 32 | for i in range(arr): 33 | for j in range(arr): 34 | if matriz[i][i] != 1: 35 | flag = False 36 | break 37 | if flag == True: 38 | return print("SI") 39 | else: 40 | return print("NO") 41 | 42 | caso = int(input("Numero caso:")) 43 | i = 0 44 | while i < caso: 45 | fila_columna = int(input("Ingrese una fila: ")) 46 | matriz = cuadradaMatriz(fila_columna) 47 | matriz_dato = rellenarMatriz(matriz,fila_columna) 48 | mostar = mostrarMatriz(matriz_dato,fila_columna) 49 | verifacion = verificadorDiagonal(matriz_dato,fila_columna) 50 | i+=1 -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #1 - Espiral Galactica/jesusPerochino.py: -------------------------------------------------------------------------------- 1 | n = 3 2 | estrellas = [0] *100 3 | indice = 0 4 | 5 | while n%2 == 1: 6 | n = int ( input()) 7 | if n%2 == 1: 8 | 9 | matriz = [[int for i in range(n)]for x in range(n)] 10 | for i in range(n): 11 | carga = input(). split() 12 | for j in range(n): 13 | matriz[i][j] = int(carga[j]) 14 | 15 | contpos = 1 16 | paso = -1 17 | posini = n // 2 18 | posinj = n // 2 19 | ciclo = 0 20 | 21 | while contpos <= n: 22 | if contpos <= n and ciclo == 0: 23 | i = 0 24 | while posini > -1 and i != contpos: 25 | estrellas[indice] += matriz[posini][posinj] 26 | 27 | 28 | i += 1 29 | posini -= 1 30 | 31 | contpos += 1 32 | ciclo = 1 33 | elif contpos <= n and ciclo == 1: 34 | j = 0 35 | while posinj < n and j != contpos: 36 | 37 | estrellas[indice] += matriz[posini][posinj] 38 | 39 | posinj += 1 40 | j += 1 41 | contpos += 1 42 | 43 | ciclo = 2 44 | 45 | elif contpos <= n and ciclo == 2 and posinj < n: 46 | i = 0 47 | 48 | while posini < n and i != contpos: 49 | 50 | estrellas[indice] += matriz[posini][posinj] 51 | posini += 1 52 | i += 1 53 | contpos += 1 54 | 55 | 56 | 57 | ciclo = 3 58 | elif contpos <= n and ciclo == 3: 59 | j = 0 60 | while posinj > -1 and j != contpos: 61 | 62 | estrellas[indice] += matriz[posini][posinj] 63 | 64 | posinj -= 1 65 | j += 1 66 | contpos += 1 67 | 68 | 69 | 70 | ciclo = 0 71 | else: 72 | contpos += 1 73 | indice += 1 74 | 75 | 76 | for i in range(indice): 77 | print(estrellas[i]) -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #9 - Volumen 1 - 151 - Es matriz identidad/AlbaHeredia.py: -------------------------------------------------------------------------------- 1 | #creo una VB para comparar los índices y otra para el ingreso 2 | Ingreso=True 3 | 4 | 5 | while Ingreso==True: 6 | 7 | #Ingreso la cantidad de filas 8 | f=int(input()) 9 | 10 | #Si f es 0, se deja de ingresar 11 | if f==0: 12 | Ingreso=False 13 | break #sale del bucle 14 | 15 | #igualo c a f ya que debe ser una matriz cuadrada 16 | c=f 17 | 18 | #creo la matriz 19 | Matriz=[[0 for j in range(c)] for i in range(f)] 20 | 21 | #cargo los valores de la matriz en una misma línea 22 | for i in range(f): 23 | fila = input() 24 | 25 | 26 | #inicializo una variable para ajustar el ind de la columna 27 | j = 0 28 | 29 | #recorro la fila 30 | for k in range(len(fila)): 31 | 32 | if fila[k] != ' ': #Si el elemento en la fila no es un espacio... 33 | Matriz[i][j] = int(fila[k]) #convierto a entero y asigno a la matriz 34 | j += 1 #incremento a la siguiente columna (ya que la que sigue sería un espacio) 35 | 36 | #creo una VB para verificar si es M.I 37 | VB=True 38 | 39 | 40 | #recorro la matriz y verifico si los valores de la DP son 1 y el resto 0 41 | for i in range(f): 42 | for j in range(c): 43 | 44 | #confirmo que la DP sea de valores 1 45 | if i == j: 46 | if Matriz[i][j] != 1: 47 | VB=False 48 | 49 | #confirmo que el resto de la matriz esté llena de 0 50 | else: 51 | if Matriz[i][j] != 0: 52 | VB=True 53 | 54 | if VB==True: 55 | print("SI") 56 | else: 57 | print("NO") 58 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #0 - Matrices Triangulares/Resolucion/resoluciónProfes.py: -------------------------------------------------------------------------------- 1 | def diagonalMatriz (matriz, longitud): 2 | # diagonalSuperior 3 | contador = 0 4 | for i in range(longitud): 5 | for k in range(longitud): 6 | if i != k and k > i: 7 | if matriz[i][k] == "0": 8 | contador += 1 9 | 10 | if contador % 3 == 0 and contador != 0: 11 | return "SI" 12 | 13 | # diagonalInferior 14 | contador = 0 15 | for i in range(longitud): 16 | for k in range(longitud): 17 | if i != k and k < i: 18 | if matriz[i][k] == "0": 19 | contador += 1 20 | 21 | if contador % 3 == 0 and contador != 0: 22 | return "SI" 23 | else: 24 | return "NO" 25 | 26 | def separarCadena (cadena, entrada): 27 | acumulador = "" 28 | a = 0 29 | vector = [""] * entrada 30 | for i in range(len(cadena)): 31 | if cadena[i] != " ": 32 | acumulador += cadena[i] 33 | 34 | if cadena[i] == " " or i == len(cadena)-1: 35 | vector[a] = acumulador 36 | a += 1 37 | acumulador = "" 38 | 39 | return vector 40 | 41 | entrada = 1 42 | a = 0 43 | resultados = [0] * 100 44 | while entrada != 0: 45 | entrada = int(input()) 46 | if entrada != 0: 47 | matriz = [[int() for ind0 in range(entrada)] for ind1 in range(entrada)] 48 | 49 | for i in range(entrada): 50 | linea = str(input()) 51 | linea = separarCadena(linea, entrada) 52 | for k in range(entrada): 53 | matriz[i][k] = linea[k] 54 | 55 | resultados[a] = diagonalMatriz(matriz, entrada) 56 | a += 1 57 | 58 | for i in range(len(resultados)): 59 | if resultados[i] != 0: 60 | print(resultados[i]) -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #0 - Matrices Triangulares/SantiagoGomez.py: -------------------------------------------------------------------------------- 1 | def sacar_espacios (cadena): 2 | n = cadena[0] 3 | for i in range (1,len(cadena)): 4 | if cadena[i] != " ": 5 | n += cadena[i] 6 | return n 7 | def tiene_diag_principal(matriz,filas): 8 | contador = 0 9 | for i in range (filas): 10 | if matriz[i][i] == 0: 11 | contador = 1 12 | if contador == 0: 13 | return "si" 14 | else: 15 | return "no" 16 | def tiene_0_abajo (matriz,filas): 17 | contador = 0 18 | for col in range(0,filas-1): 19 | for fila in range(1,filas): 20 | if fila > col: 21 | if matriz[fila][col] != 0: 22 | contador = 1 23 | if contador == 0: 24 | return "si" 25 | else: 26 | return "no" 27 | def tiene_0_arriba (matriz,filas): 28 | contador = 0 29 | for fila in range(0,filas-1): 30 | for col in range(1,filas): 31 | if col > fila: 32 | if matriz[fila][col] != 0: 33 | contador = 1 34 | if contador == 0: 35 | return "si" 36 | else: 37 | return "no" 38 | 39 | filas = int(input()) 40 | while (filas > 0) and (filas < 50): # Mientras la dimencion de la matriz sea entre 1 y 49 41 | matriz = [[int(0)for i in range(filas)]for j in range (filas)] 42 | for i in range (filas): 43 | entrada = input() 44 | entrada = sacar_espacios(entrada) 45 | for j in range (filas): 46 | matriz[i][j] = int(entrada[j]) # Matriz definida con sus elementos 47 | if tiene_diag_principal(matriz,filas) == "si": # Verificar si tiene diagonal principal diferente a 0 48 | if (tiene_0_abajo(matriz,filas) == "si")or(tiene_0_arriba(matriz,filas) == "si"): # Verificar si tiene todos ceros abajo o arriba 49 | print("SI") 50 | else: 51 | print("NO") 52 | else: 53 | print("NO") 54 | filas = int(input()) 55 | 56 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #16 - Volumen 4 - 400 - Durmiendo en albergues/Durmiendo en Albergues Lautaro Villarreal.py: -------------------------------------------------------------------------------- 1 | def resultado(): 2 | disp = input() 3 | if disp == "": 4 | return "cortar" 5 | for i in disp: 6 | if i != "." and i != "x" and i == 0 or i == " ": 7 | return "cortar" 8 | equis = [-1] * 500000 9 | indice = 0 10 | for eq in range(len(disp)): 11 | if disp[eq] == "x": 12 | equis[indice] = eq 13 | indice+=1 14 | equis_indices = [0] * indice 15 | for i in range(indice): 16 | equis_indices[i] = equis[i] 17 | for izquierda in range(len(disp)): 18 | if disp[izquierda] == "x": 19 | lugares_izquierda = izquierda 20 | break 21 | for derecha in range(len(disp)-1,-1,-1): 22 | if disp[derecha] == "x": 23 | lugares_derecha = len(disp)-derecha-1 24 | break 25 | if lugares_izquierda >= lugares_derecha: 26 | mayor_esquina = lugares_izquierda 27 | mayor_indice = 0 28 | else: 29 | mayor_esquina = lugares_derecha 30 | mayor_indice = -1 31 | mayor_cant_esquina = mayor_esquina-1 32 | diferencia = 0 33 | for lugares_disp in range(len(equis_indices)-1): 34 | inicio = equis_indices[lugares_disp] 35 | final = equis_indices[lugares_disp+1] 36 | dif_moment = final - inicio - 1 37 | if dif_moment > diferencia: 38 | empieza = equis_indices[lugares_disp] 39 | termina = equis_indices[lugares_disp+1] 40 | diferencia = dif_moment 41 | if diferencia%2 == 0: espacio_mas_grande = (diferencia/2)-1 42 | else: espacio_mas_grande = (diferencia//2) 43 | if espacio_mas_grande > mayor_cant_esquina: return(int(espacio_mas_grande)) 44 | else:return(int(mayor_cant_esquina)) 45 | total = "" 46 | termina = 0 47 | while True: 48 | sumar = resultado() 49 | if sumar == "cortar": 50 | break 51 | total+=str(sumar) 52 | for r in total: 53 | print(r) -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #9 - Volumen 1 - 151 - Es matriz identidad/SantiagoToniollo.py: -------------------------------------------------------------------------------- 1 | def crear_matriz(dimension): 2 | identidad = [[1 if i == j else 0 for j in range(dimension)] for i in range(dimension)] 3 | return identidad 4 | 5 | def imprimir_resultados(resultados): 6 | for resultado in resultados: 7 | print(resultado) 8 | 9 | def matriz_identidad(): 10 | resultados = [] #donde almacenaremos los resultados 11 | 12 | while True: 13 | #se solicita la dimensión de la matriz 14 | n = int(input("Ingresar un numero para la dimension de la matriz:")) 15 | if n == 0: 16 | imprimir_resultados(resultados) #imprimir los resultados acumulados 17 | print("Programa terminado") 18 | break 19 | 20 | identidad = crear_matriz(n) #se crea la matriz identidad 21 | matriz_usuario = [] #inicializar la matriz vacía 22 | for i in range(n): 23 | fila = [0] * n #para crear una fila de ceros 24 | matriz_usuario += [fila] 25 | 26 | print("Ingresar la matriz fila por fila") 27 | for i in range(n): 28 | fila = input(f"Ingrese la fila {i + 1}: ") 29 | num_actual = "" 30 | pos = 0 31 | for caracter in fila: 32 | if caracter != " ": #si no es un espacio, se añade al número actual 33 | num_actual += caracter 34 | else: #si lo es, convertir el número acumulado y ponerlo en la matriz 35 | matriz_usuario[i][pos] = int(num_actual) 36 | num_actual = "" 37 | pos += 1 38 | if num_actual: 39 | matriz_usuario[i][pos] = int(num_actual) 40 | 41 | es_identidad = True 42 | for i in range(n): 43 | for j in range(n): 44 | if matriz_usuario[i][j] != identidad[i][j]: 45 | es_identidad = False 46 | break 47 | 48 | if es_identidad: 49 | resultados += ["SI"] 50 | else: 51 | resultados += ["NO"] 52 | 53 | matriz_identidad() 54 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #9 - Volumen 1 - 151 - Es matriz identidad/BenjaminVidela.py: -------------------------------------------------------------------------------- 1 | i = j = filxcol = f = f2 = fr = numerito = 0 2 | mat = [[0 for _ in range(50)] for _ in range(50)] 3 | resultados = [0.0 for _ in range(100)] 4 | 5 | while True: 6 | filxcol = int(input("Dimension: ")) 7 | if 0 < filxcol <= 50: 8 | f = f2 = 0 9 | #en el for ahora trato cada fila como cadena para poder poner por ejemplo : 1 0 0 (enter) 10 | #asi evito poner un numero por linea 11 | for i in range(filxcol): 12 | fila_input = input(f"Fila {i + 1}: ") 13 | j = 0 14 | numcadena = "" 15 | 16 | for caracter in fila_input: 17 | if caracter != " ": 18 | numcadena += caracter 19 | else: 20 | if numcadena: 21 | numerito = int(numcadena) 22 | if not (-1000 <= numerito <= 1000): 23 | f = f2 = 1 24 | else: 25 | mat[i][j] = numerito 26 | j += 1 27 | numcadena = "" 28 | 29 | 30 | if numcadena: 31 | numerito = int(numcadena) 32 | if not (-1000 <= numerito <= 1000): 33 | f = f2 = 1 34 | else: 35 | mat[i][j] = numerito 36 | 37 | if not f: 38 | for i in range(filxcol): 39 | for j in range(filxcol): 40 | if (i == j and mat[i][j] != 1) or (i != j and mat[i][j] != 0): 41 | f2 = 1 42 | 43 | resultados[fr] = 1 if not f2 else 0 44 | fr += 1 45 | else: 46 | if filxcol != 0: 47 | resultados[fr] = -1 48 | fr += 1 49 | 50 | if filxcol == 0: 51 | break 52 | 53 | for i in range(fr): 54 | if resultados[i] == 1: 55 | print("SI") 56 | elif resultados[i] == 0: 57 | print("NO") 58 | elif resultados[i] == -1: 59 | print("INVALIDO") #por si ingreso un valor para la dimension fuera del rango (0 a 50) 60 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #10 - Volumen 1 - 154 - Cuál es la siguiente matrícula/Resolución/Volumen 1 - 154 - Cuál es la siguiente matrícula.py: -------------------------------------------------------------------------------- 1 | #FUNCIÓN 2 | def mat_siguiente(cadena): 3 | cadena = cadena.upper() 4 | digitos = cadena[0 : 4] 5 | letras = cadena[5 : 8] 6 | caracteres = "BCDFGHJKLMNPQRSTVWXYZ" 7 | 8 | if digitos != "9999": 9 | digitos = str(int(digitos) + 1) 10 | salida = digitos + " " + letras 11 | 12 | elif digitos == "9999": 13 | digitos = "0000" 14 | 15 | #Aumentamos en 1 a letras 16 | if letras[2:3] != "Z": 17 | for i in range(len(caracteres)): 18 | if caracteres[i:i+1] == letras[2:3]: 19 | letra_actual = i 20 | 21 | salida = digitos + " " + letras[0:2] + caracteres[(letra_actual+1): (letra_actual+2)] 22 | 23 | #Si sólo el último caracter es Z 24 | elif letras[1:2] != "Z" and letras[2:3] == "Z": 25 | letras = letras[0 : 2] + "B" 26 | for i in range(len(caracteres)): 27 | if caracteres[i:i+1] == letras[1:2]: 28 | letra_actual = i 29 | 30 | salida = digitos + " " + letras[0:1] + caracteres[(letra_actual+1): (letra_actual+2)] + letras[2:3] 31 | 32 | #Si los últimos dos carácteres son Z 33 | elif letras[1:2] == "Z" and letras[2:3] == "Z": 34 | letras = letras[0:1] + "B" + "B" 35 | for i in range(len(caracteres)): 36 | if caracteres[i:i+1] == letras[0:1]: 37 | letra_actual = i 38 | 39 | salida = digitos + " " + caracteres[(letra_actual+1): (letra_actual+2)] + letras[1:3] 40 | 41 | return salida 42 | 43 | 44 | #INICIALIZACIÓN DE VARIABLES 45 | salir = 0 46 | vector_salidas = 100 * [""] 47 | contador = 0 48 | 49 | #ENTRADAS 50 | while salir == 0: 51 | cadena = str(input()) 52 | cadena = cadena.upper() 53 | 54 | if cadena == "9999 ZZZ": 55 | salir = 1 56 | else: 57 | #PROCESOS Y SALIDAS 58 | vector_salidas[contador] = mat_siguiente(cadena) 59 | contador = contador + 1 60 | 61 | for i in range(100): 62 | if vector_salidas[i] != "": 63 | print(vector_salidas[i], end = "\n") -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #1 - Espiral Galactica/lautaroRoldan.py: -------------------------------------------------------------------------------- 1 | entrada = int(input()) 2 | 3 | while (entrada% 2) != 0: 4 | 5 | matriz = [[str() for ind0 in range(1*entrada)]for ind1 in range(1*entrada)] 6 | 7 | for i in range(entrada): 8 | pal = str(input()) 9 | vec = pal.split(" ") 10 | for h in range(entrada): 11 | matriz[i][h] = int(vec[h]) 12 | 13 | i = round((entrada-1)/2) 14 | h = round((entrada-1)/2) 15 | 16 | suma = matriz[i][h] 17 | 18 | 19 | if entrada > 1 : 20 | suma = suma + matriz[i-1][h] 21 | i = i - 1 22 | 23 | 24 | cont = 3 25 | cond = True 26 | a = 1 27 | 28 | while cond == True: 29 | for j in range(1,cont): 30 | if (h+j) <= (entrada-1): 31 | suma = suma + matriz[i][h+j] 32 | a = a + 1 33 | 34 | if a == cont: 35 | h = h + j 36 | a = 1 37 | cont = cont + 1 38 | else: 39 | a = 1 40 | cond = False 41 | 42 | for j in range(1,cont): 43 | if (i+j) <= (entrada-1): 44 | suma = suma + matriz[i+j][h] 45 | a = a + 1 46 | if a == cont: 47 | i = i + j 48 | a = 1 49 | cont = cont + 1 50 | else: 51 | a = 1 52 | cond = False 53 | 54 | if cond == True: 55 | for j in range(1,cont): 56 | if (h-j) >= (0): 57 | suma = suma + matriz[i][h-j] 58 | a = a + 1 59 | if a == cont: 60 | h = h - j 61 | a = 1 62 | cont = cont + 1 63 | else: 64 | a = 1 65 | cond = False 66 | 67 | if cond == True: 68 | for j in range(1,cont): 69 | if (i-j) >= (0): 70 | suma = suma + matriz[i-j][h] 71 | a = a + 1 72 | if a == cont: 73 | i = i - j 74 | a = 1 75 | cont = cont + 1 76 | else: 77 | a = 1 78 | cond = False 79 | 80 | print(suma) 81 | entrada = int(input()) 82 | 83 | 84 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #9 - Volumen 1 - 151 - Es matriz identidad/NicolasCesolari.py: -------------------------------------------------------------------------------- 1 | def SepararEntrada(numeros, matriz, filas,f): 2 | c = 0 3 | cantidad = len(numeros) 4 | numero = "" 5 | 6 | for i in range(cantidad): 7 | if numeros[i] != " ": 8 | numero += numeros[i] 9 | else: 10 | if -1000<=int(numero)<=1000: 11 | matriz[f][c] = numero 12 | numero = "" 13 | c += 1 14 | else: 15 | return None,None 16 | 17 | if i == cantidad-1 and -1000<=int(numero)<=1000: 18 | matriz[f][c] = numero 19 | else: 20 | return None,None 21 | f += 1 22 | return matriz, f 23 | 24 | def MatrizIdentidad(matriz, filas): 25 | #Abajo 26 | respuesta_1 = "SI" 27 | for i in range(1,filas,1): 28 | for j in range(0,i,1): 29 | if matriz[i][j] != "0": 30 | respuesta_1 = "NO" 31 | #Arriba 32 | respuesta_2 = "SI" 33 | k=1 34 | for i in range(0,filas-1,1): 35 | for j in range(k,filas,1): 36 | if matriz[i][j]!="0": 37 | respuesta_2 = "NO" 38 | k+=1 39 | #Diagonal 40 | respuesta_3 = "SI" 41 | for i in range(filas): 42 | for j in range(filas): 43 | if i == j : 44 | if matriz[i][j]!="1": 45 | respuesta_3 = "NO" 46 | 47 | if respuesta_1 == "SI" and respuesta_2 == "SI" and respuesta_3 == "SI": 48 | return "SI" 49 | else: 50 | return "NO" 51 | #Algoritmo 52 | bandera = True 53 | while bandera: 54 | filas = int(input()) 55 | if (filas != 0 and filas < 50): 56 | matriz = [[""]*filas for i in range(filas)] 57 | f = 0 58 | for i in range(filas): 59 | numeros = input() 60 | matriz,f = SepararEntrada(numeros, matriz,filas, f) 61 | if matriz == None: 62 | print("Error, los numeros deben cumplir las condiciones, seleccione de nuevo las filas y numeros") 63 | break 64 | if matriz!= None: 65 | respuesta = MatrizIdentidad(matriz, filas) 66 | print(respuesta) 67 | else: 68 | bandera = False 69 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #9 - Volumen 1 - 151 - Es matriz identidad/AbrilCarballo.py: -------------------------------------------------------------------------------- 1 | def main(): 2 | dimension = int(input('Dim: ')) 3 | while dimension <= 50 and dimension != 0: 4 | # llamo a las funciones 5 | matriz = crear_matriz_desde_vectores(dimension) 6 | bandera = verificar_identidad(matriz, dimension) 7 | 8 | # verifico si es identidad o no 9 | if bandera == 1: 10 | print('SI') 11 | else: 12 | print('NO') 13 | 14 | dimension = int(input('Dim: ')) 15 | 16 | def crear_matriz_desde_vectores(dimension): 17 | matriz = [] 18 | for i in range(dimension): # [0] porque solo queremos el primer elemento del vector que son las filas 19 | filas = vector(input('Fila: ')) 20 | matriz += [filas] 21 | 22 | return matriz 23 | 24 | # Convierte la cadena leída en una lista de enteros (un vector) 25 | def vector(cadena): # cadena es una copia de fila 26 | v = [] # Inicializa un vector vacío donde se almacenarán los números 27 | sub = "" # Inicializa una subcadena vacía para construir cada número de la cadena 28 | 29 | # Itera a través de cada carácter de la cadena 30 | for i in range(len(cadena)): 31 | if cadena[i] == " ": # Si el carácter actual es un espacio 32 | v += [int(sub)] # Convierte la subcadena actual en entero y la agrega al vector 33 | sub = "" # Reinicia la subcadena para el siguiente número 34 | else: 35 | sub = sub + cadena[i] # Agrega el carácter actual a la subcadena 36 | 37 | # Al final del bucle, agrega la última subcadena al vector si no termina en espacio 38 | if cadena[len(cadena)-1] != " ": 39 | v += [int(sub)] # Convierte la última subcadena en entero y la agrega al vector 40 | 41 | return v # Devuelve el vector resultante de enteros 42 | 43 | def verificar_identidad(matriz, dim): 44 | for i in range(dim): 45 | for j in range(dim): 46 | if i == j: # diagonal principal 47 | if matriz[i][j] != 1: 48 | return 0 49 | else: # elementos fuera de la diagonal 50 | if matriz[i][j] != 0: 51 | return 0 52 | # si devuelve 1 es porque los elementos son 1 y 0, en sus ubicaciones correspondientes 53 | return 1 54 | main() -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #12 - Volumen 1 - 163 - Súmale 1/Resolución/Volumen 1 - 163 - Súmale 1.py: -------------------------------------------------------------------------------- 1 | #FUNCIÓN 2 | def hex_siguiente(cadena): 3 | #INICIALIZACIÓN DE VARIABLES 4 | 5 | in_usuario = "0" + cadena #Añadimos un 0 a la izquierda para los números cuyos dígitos son todos F 6 | in_usuario = in_usuario.upper() 7 | caracteres = "0123456789ABCDEF" 8 | 9 | capacidad_vector = 100 10 | vector_F = capacidad_vector * [0] 11 | contador = 0 12 | 13 | #PROCESOS 14 | if in_usuario[len(in_usuario)-1 : len(in_usuario)] != "F": 15 | 16 | #Si el último caracter NO es una F, lo aumentamos en 1. 17 | for i in range(len(caracteres)): 18 | if in_usuario[len(in_usuario)-1 : len(in_usuario)] == caracteres[i : i+1]: 19 | pos_encontrada = i 20 | 21 | #Concatenamos el nuevo caracter al resto de la cadena 22 | in_usuario = in_usuario[0: len(in_usuario)-1] + caracteres[pos_encontrada+1 : pos_encontrada+2] 23 | return in_usuario[1 : len(in_usuario)] 24 | else: 25 | #Si el último caracter es una F significa que tenemos que hacerlo 0 y aumentar en 1 al caracter de su izquierda. 26 | #Disminuimos en 1 la cadena ingresada para que no se tome al último caracter, que será un 0 27 | in_usuario = hex_siguiente(in_usuario[0 : len(in_usuario)-1]) + "0" 28 | 29 | return in_usuario[1 : len(in_usuario)] 30 | 31 | #INICIALIZACIÓN DE VARIABLES 32 | salir = 0 33 | vector_salidas = 100 * [""] 34 | contador = 0 35 | 36 | #ENTRADAS 37 | while salir == 0: 38 | ceros = "" 39 | cadena = str(input()) 40 | cadena = cadena.upper() 41 | 42 | if cadena == "FIN": 43 | salir = 1 44 | else: 45 | #PROCESOS Y SALIDAS 46 | #Si la función devuelve todos 0, tenemos que añadir un 1 a la izquierda 47 | 48 | #Generamos una cadena de 0 del largo de la cadena originalmente ingresada 49 | for i in range(len(cadena)): 50 | ceros = "0" + ceros 51 | 52 | if hex_siguiente(cadena) == ceros: 53 | vector_salidas[contador] = "1" + hex_siguiente(cadena) 54 | else: 55 | vector_salidas[contador] = hex_siguiente(cadena) 56 | 57 | contador = contador + 1 58 | 59 | for i in range(100): 60 | if vector_salidas[i] != "": 61 | print(vector_salidas[i], end = "\n") -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #16 - Volumen 4 - 400 - Durmiendo en albergues/AlbaHeredia.py: -------------------------------------------------------------------------------- 1 | #inicializo contadores 2 | contador_camas_ocupadas=0 3 | DistanciaMáxima=0 4 | 5 | cadena=str(input()) 6 | 7 | #compruebo que cumpla con tener menos de 50mil caracteres 8 | if len(cadena) < 500000: 9 | 10 | entrada=True 11 | 12 | #si cumple, verifico que solo sea de puntos y x 13 | for i in range(len(cadena)): 14 | if cadena[i] != "." and cadena[i] != "x": 15 | entrada=False 16 | break 17 | 18 | #si cumple que sea de puntos y x 19 | if entrada==True: 20 | 21 | #creo una subcadena para guardar las pos de las x (indices) 22 | subcadena=[0]*len(cadena) 23 | 24 | #verifico que los extremos sean x (por si la distancia max está en un extremo) 25 | 26 | if cadena[0] != "x": #si el 1er elemento no es "x" 27 | cadena = "x" + cadena[1:] #concateno "x" al inicio de la cadena 28 | if cadena[-1] != "x": #si el último elemento no es "x" 29 | cadena = cadena[:-1] + "x" #concateno "x" al final de la cadena 30 | 31 | #recorro y cuento la cantidad de camas ocupadas 32 | for i in range(len(cadena)): 33 | 34 | if cadena[i] == "x": 35 | subcadena[contador_camas_ocupadas] = i 36 | contador_camas_ocupadas += 1 37 | 38 | 39 | subcadena=subcadena[:contador_camas_ocupadas] #me quedo únicamente con la cantidad de camas ocupadas 40 | 41 | #print(subcadena) 42 | #print(contador_camas_ocupadas) 43 | 44 | 45 | for j in range(contador_camas_ocupadas-1): 46 | Distancia=subcadena[j+1]-subcadena[j] #calculo distancia 47 | 48 | Distancia -= 1 #resto uno para ajustar 49 | 50 | if Distancia % 2 == 0: #si es par 51 | DistanciaActual = (Distancia // 2) -1 52 | 53 | if Distancia == 1: 54 | DistanciaActual = 0 55 | 56 | if Distancia % 2 != 0 and DistanciaActual != 1: 57 | DistanciaActual = Distancia//2 58 | 59 | 60 | if DistanciaActual > DistanciaMáxima: 61 | DistanciaMáxima = DistanciaActual 62 | 63 | print(DistanciaMáxima) 64 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #11 - Volumen 1 - 162 - Tableros de Ajedrez/Resolución/Volumen 1 - 162 - Tableros de Ajedrez.py: -------------------------------------------------------------------------------- 1 | #ENTRADAS 2 | 3 | #El usuario ingresará en una sola línea el tamaño de los cuadrados y qué carácter estáran formados los recuadros negros 4 | cadena = str(input()) 5 | 6 | #PROCESOS 7 | #Extraemos el tamaño de los cuadrados y el caracter 8 | for i in range(len(cadena)): 9 | if cadena[i : i+1] == " ": 10 | espacio = i 11 | 12 | tamaño = int(cadena[0 : espacio]) 13 | caracter_negro = cadena[espacio+1 : len(cadena)] 14 | 15 | #Generamos cadenas del tamaño designado 16 | cadena_blanco = "" 17 | cadena_negro = "" 18 | 19 | #Para los cuadrados blancos usamos el espacio 20 | for i in range(tamaño): 21 | cadena_blanco = cadena_blanco + " " 22 | 23 | #Para los cuadrados negros usamos el indicado por el usuario 24 | for i in range(tamaño): 25 | cadena_negro = cadena_negro + caracter_negro 26 | 27 | 28 | #SALIDAS 29 | 30 | #Encabezado 31 | encabezado = "" 32 | for i in range(tamaño * 8): 33 | encabezado = encabezado + "-" 34 | encabezado = "|" + encabezado + "|" 35 | 36 | 37 | print(encabezado) 38 | for i in range(8): 39 | for j in range(tamaño): 40 | if i % 2 == 0: 41 | for k in range(8): 42 | if k % 2 == 0: 43 | if k == 0: 44 | print("|", end = "") 45 | 46 | print(cadena_blanco, end = "") 47 | 48 | if k == 7: 49 | print("|", end = "") 50 | else: 51 | if k == 0: 52 | print("|", end = "") 53 | 54 | print(cadena_negro, end = "") 55 | 56 | if k == 7: 57 | print("|", end = "") 58 | else: 59 | for k in range(8): 60 | if k % 2 == 0: 61 | if k == 0: 62 | print("|", end = "") 63 | 64 | print(cadena_negro, end = "") 65 | 66 | if k == 7: 67 | print("|", end = "") 68 | else: 69 | if k == 0: 70 | print("|", end = "") 71 | 72 | print(cadena_blanco, end = "") 73 | 74 | if k == 7: 75 | print("|", end = "") 76 | print("") 77 | print(encabezado) -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #9 - Volumen 1 - 151 - Es matriz identidad/lautaroVillarreal.py: -------------------------------------------------------------------------------- 1 | tamaño,result = int(input()),"" 2 | def carga_matriz(): 3 | #definimos la matriz 4 | matriz = [[0 for c in range(tamaño)]for f in range(tamaño)] 5 | for filas in range(tamaño): 6 | #pedimos que se ingrese "palabra" (sea la fila de la matriz) 7 | palabra = input() 8 | 9 | #si la palabra tiene un espacio al final, se lo quitamos 10 | if palabra[-1] == " ": palabra = palabra[0:len(palabra)-1] 11 | 12 | 13 | numero,col = "",0 14 | for i in range(len(palabra)): 15 | #recorremos la palabra mientras sea distinta a un espacio y la guardamos en "num" 16 | if palabra[i] != " ": numero+=palabra[i] 17 | 18 | #si el caracter es un espacio, hacemos entero a la variable num y la incertamos en la matriz 19 | else: 20 | matriz[filas][col] = int(numero) 21 | col+=1 22 | numero = "" 23 | #Incertamos lo que quedó de la palabra el final de la matriz 24 | matriz[filas][col] = int(numero) 25 | 26 | return matriz 27 | 28 | def resultado(): 29 | #iniciamos la variable en la que vamos a sumar, y a la que usamos para controlar la diagonal 30 | suma,esquina = 0,0 31 | for f in range(tamaño): 32 | if f == esquina: 33 | #verificamos lo que hay en la esquina, si es distinto de 1, entonces la matriz no es D. 34 | if matriz[esquina][esquina] != 1: 35 | esquina+=1 36 | return "NO" 37 | for c in range(tamaño): 38 | #sumamos toda la diagonal, suma la cual (en la mat. identidad) debe ser si o si igual al rango. 39 | suma+=matriz[f][c] 40 | 41 | #vemos si la suma de la diagonal es igual al rango, si es mayor quiere decir que en la misma hay algo destinto de 1. 42 | if suma > tamaño: return "NO" 43 | #si la suma es igual al tamaño, entonces es diagonal 44 | if suma == tamaño: return "SI" 45 | suma,esquina = 0,0 46 | while tamaño != 0: 47 | matriz = carga_matriz() 48 | result+=resultado() 49 | tamaño = int(input()) 50 | 51 | #imprimimos la cadena de resulado utilizandola como subcadena 52 | for i in range(0,len(result),2): print(result[i:i+2]) -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #1 - Espiral Galactica/AgustinMagallanes.py: -------------------------------------------------------------------------------- 1 | dimension = int(input("Ingrese tamaño de matriz: ")) 2 | matriz = [[None for i in range(dimension)]for j in range(dimension)] 3 | 4 | for i in range(dimension): 5 | elementos = input("Ingrese los elementos de cada fila: ") 6 | for j in range(dimension): 7 | matriz[i][j] = int(elementos[j]) 8 | 9 | centro = int((dimension/2) + 0.5)-1 10 | 11 | # Declarar variables iniciales 12 | filas = centro 13 | columnas = centro 14 | solucion = matriz[centro][centro] 15 | contador = 1 16 | Flag = True 17 | 18 | 19 | while Flag: 20 | #Resta 1 fila, sube 21 | if filas - contador >= 0: 22 | for i in range(contador): 23 | filas -= 1 24 | solucion += matriz[filas][columnas] 25 | contador +=1 26 | else: 27 | for i in range(dimension-1): 28 | filas -= 1 29 | solucion += matriz[filas][columnas] 30 | Flag = False 31 | contador +=1 32 | 33 | #Sumo 2 columna, derecha 34 | if Flag: 35 | if columnas+contador < dimension: 36 | for i in range(contador): 37 | columnas += 1 38 | solucion += matriz[filas][columnas] 39 | contador += 1 40 | else: 41 | for i in range(columnas, dimension-1): 42 | columnas += 1 43 | solucion += matriz[filas][columnas] 44 | Flag = False 45 | contador +=1 46 | 47 | #Sumo 3 filas, abajo 48 | if Flag: 49 | if filas + contador < dimension: 50 | for i in range(contador): 51 | filas += 1 52 | solucion += matriz[filas][columnas] 53 | contador += 1 54 | else: 55 | for i in range(dimension-1): 56 | columnas += 1 57 | solucion += matriz[filas][columnas] 58 | Flag = False 59 | contador +=1 60 | 61 | 62 | #Resto 4 columnas, izquierda 63 | if Flag: 64 | if columnas - contador >= 0: 65 | for i in range(contador): 66 | columnas -= 1 67 | solucion += matriz[filas][columnas] 68 | contador +=1 69 | else: 70 | for i in range(dimension-1): 71 | columnas -= 1 72 | solucion += matriz[filas][columnas] 73 | Flag = False 74 | contador +=1 75 | 76 | 77 | print(solucion) 78 | 79 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #16 - Volumen 4 - 400 - Durmiendo en albergues/Resolución/Volumen 4 - 400 - Durmiendo en albergues.py: -------------------------------------------------------------------------------- 1 | print("Ingrese la disposición de camas (. = libre; X = ocupado)") 2 | cadena = str(input("→ ")) 3 | 4 | if len(cadena) < 500000: 5 | #Revisamos que la cadena ingresada esté formada solamente por . y X 6 | cadena_lower = cadena.lower() 7 | input_erroneo = 0 8 | 9 | for i in range(len(cadena_lower)): 10 | if cadena_lower[i : i+1] != "." and cadena_lower[i : i+1] != "x": 11 | print("analizando",cadena_lower[i:i+1]) 12 | input_erroneo = 1 13 | 14 | if input_erroneo == 0: 15 | 16 | #Ubicamos la posición de cada cama ocupada X 17 | camas_ocupadas = 20 * [-1] 18 | cant_ocupadas = 0 19 | for i in range(len(cadena_lower)): 20 | if cadena_lower[i : i+1] == "x": 21 | camas_ocupadas[cant_ocupadas] = i 22 | cant_ocupadas = cant_ocupadas + 1 23 | 24 | print(camas_ocupadas,cant_ocupadas) 25 | #Analizamos los espacios ENTRE las camas ocupadas 26 | distancia_max = 0 27 | for i in range(cant_ocupadas-1): 28 | if cadena_lower[i+1] != -1: 29 | distancia_neta = len(cadena_lower[camas_ocupadas[i]+1 : camas_ocupadas[i+1]]) 30 | 31 | if distancia_neta % 2 == 0: 32 | distancia_auxiliar = (distancia_neta / 2) - 1 33 | 34 | if distancia_neta == 1: 35 | distancia_auxiliar = 0 36 | 37 | if (distancia_neta != 1) and ((distancia_neta % 2) != 0): 38 | distancia_auxiliar = int(distancia_neta/2) 39 | 40 | #Si encontramos una distancia mayor a la actual, la reemplazamos 41 | if distancia_auxiliar > distancia_max: 42 | distancia_max = distancia_auxiliar 43 | 44 | 45 | #Analizamos los espacios de los EXTREMOS: Desde el inicio hasta la primer cama ocupada y desde la última cama hasta el final 46 | 47 | #Extremo izquierdo 48 | distancia_neta = len(cadena_lower[0 : camas_ocupadas[0]]) 49 | distancia_auxiliar = distancia_neta - 1 50 | if distancia_auxiliar > distancia_max: 51 | distancia_max = distancia_auxiliar 52 | 53 | #Extremo derecho 54 | distancia_neta = len(cadena_lower[camas_ocupadas[cant_ocupadas-1]+1 : len(cadena_lower)]) 55 | distancia_auxiliar = distancia_neta - 1 56 | if distancia_auxiliar > distancia_max: 57 | distancia_max = distancia_auxiliar 58 | 59 | print(int(distancia_max)) -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #16 - Volumen 4 - 400 - Durmiendo en albergues/AbrilCarballo.py: -------------------------------------------------------------------------------- 1 | def main(): 2 | cp = int(input('Ingrese casos de prueba: ')) 3 | 4 | for i in range(cp): 5 | camas = input('Camas: ') 6 | if len(camas) > 500000: 7 | break 8 | else: 9 | total_izq = leer_izq(camas) 10 | total_der = leer_der(camas) 11 | total_medio = leer_medio(camas) 12 | 13 | resultado = menor(total_der,total_izq,total_medio) 14 | if resultado == None: 15 | resultado = 0 16 | 17 | print(resultado) 18 | 19 | def leer_izq(camas): # .....x 20 | total_izq = -1 21 | for i in range(len(camas)): 22 | if camas[i] == ".": 23 | total_izq += 1 24 | if camas[i] == "x": 25 | return total_izq 26 | return total_izq 27 | 28 | def leer_der(camas): # x..... 29 | total_der = -1 30 | for i in range(len(camas) - 1, -1, -1): 31 | if camas[i] == ".": 32 | total_der += 1 33 | if camas[i] == "x": 34 | return total_der 35 | return total_der 36 | 37 | def leer_medio(camas): # x....x 38 | distancia_actual = 0 39 | hay_x = False 40 | max_distancia_medio = 0 41 | 42 | for i in range(len(camas)): 43 | if camas[i] == "x": 44 | if hay_x: # Si ya encontramos una 'x' antes, verificamos la distancia 45 | if distancia_actual % 2 == 0: # Par 46 | distancia_calculada = (distancia_actual // 2) - 1 47 | else: # Impar 48 | distancia_calculada = distancia_actual // 2 49 | 50 | # Asignamos el valor mayor entre lo que ya tenemos y la nueva distancia 51 | if distancia_calculada > max_distancia_medio: 52 | max_distancia_medio = distancia_calculada 53 | hay_x = True # Marcamos que hemos encontrado la primera 'x' 54 | distancia_actual = 0 # Reiniciamos el contador de distancia 55 | 56 | elif hay_x: # Contamos las camas vacías entre 'x' 57 | distancia_actual += 1 58 | 59 | return max_distancia_medio 60 | 61 | def menor(total_der,total_izq,total_medio): 62 | # Inicializamos una variable para almacenar el menor valor 63 | men = None 64 | 65 | # Comprobamos cada valor y actualizamos 'men' si es válido 66 | if total_der > 0: 67 | men = total_der 68 | if total_izq > 0: 69 | if men is None or total_izq > men: 70 | men = total_izq 71 | if total_medio > 0: 72 | if men is None or total_medio > men: 73 | men = total_medio 74 | 75 | return men 76 | 77 | main() 78 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #7 - Volumen 1 - 107 - Aproximación de gauss/Resolución/Volumen 1 - 107 - Aproximación de gauss.py: -------------------------------------------------------------------------------- 1 | # Función para imprimir números primos en el rango de un número dado `n` 2 | # Este algoritmo es la Temiz de Eratóstenes (o Sieve of Eratosthenes) 3 | def cant_primos(num): 4 | contador = 0 5 | #Cada posición de este vector representará un número entero. El elemento contenido dentro de este 6 | #vector determinará si el número de esa posición es primo (1) o no (0). Al empezar se considera que todos son primos, por lo que 7 | #inicializamos a vector_primos con un 1 en cada uno de sus elementos. 8 | vector_primos = [1] * (num + 1) 9 | 10 | for i in range(2, int(num**(1/2)) + 1): 11 | if vector_primos[i] == 1: # comprueba si i es primo (es decir si vale 1) 12 | j = 2 13 | while i * j <= num: 14 | vector_primos[i * j] = 0 # múltiplos de i no son primos 15 | j = j + 1 16 | 17 | for i in range(2, num + 1): 18 | if vector_primos[i] == 1: 19 | contador = contador + 1 #aumentamos en 1 la cantidad de primos 20 | 21 | return contador 22 | 23 | 24 | #INICIALIZACIÓN DE VARIABLES 25 | import math 26 | salir = 0 27 | 28 | #ENTRADAS Y PROCESOS 29 | while salir == 0: 30 | 31 | #INICIALIZACIÓN DE VARIABLES 32 | invalido = 0 33 | bandera = 0 34 | n = 0 35 | m = 0 36 | 37 | #ENTRADAS 38 | cadena_input = str(input()) 39 | 40 | #PROCESOS 41 | for i in range(len(cadena_input)): 42 | if bandera == 0 and cadena_input[i:i+1] == " ": 43 | pos_espacio = i 44 | bandera = 1 45 | 46 | if len(cadena_input[0 : pos_espacio]) > 6: 47 | invalido = 1 48 | if int(cadena_input[0 : pos_espacio]) < 100000 and int(cadena_input[0 : pos_espacio]) > 0: 49 | n = int(cadena_input[0 : pos_espacio]) 50 | else: 51 | invalido = 1 52 | 53 | if len(cadena_input[pos_espacio+1 : len(cadena_input)]) == 1 and (int(cadena_input[pos_espacio+1 : len(cadena_input)]) >= 0 and int(cadena_input[pos_espacio+1 : len(cadena_input)]) <=5): 54 | m = int(cadena_input[pos_espacio+1 : len(cadena_input)]) 55 | else: 56 | invalido = 1 57 | 58 | if n == 0 and m == 0: 59 | salir = 1 60 | elif invalido == 0: 61 | error_gauss = abs(((cant_primos(n)) / n) - (1 / (math.log(n, math.e)))) 62 | 63 | error_decimal = (1 / (10**m)) 64 | if error_gauss > error_decimal: 65 | estado = "Mayor" 66 | else: 67 | estado = "Menor" 68 | 69 | if error_decimal == error_gauss: 70 | estado = "Igual" 71 | 72 | print(estado) -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #16 - Volumen 4 - 400 - Durmiendo en albergues/Ejercicio #16 - Santiago Garcia.py: -------------------------------------------------------------------------------- 1 | def camasdisp(prueba,situacion): 2 | espacios=-1 3 | bandera2=0 4 | espaciostotales=0 5 | if situacion==0: 6 | for i in range(len(prueba)): 7 | if prueba[i]==".": 8 | espacios+=1 9 | if prueba[i]=="x" or i==(len(prueba))-1: 10 | if espacios>espaciostotales and (bandera2==0 or i==(len(prueba))-1): 11 | espaciostotales=espacios 12 | elif espacios/2>espaciostotales and espacios%2==0: 13 | espaciostotales=int(espacios/2) 14 | elif espacios//2>espaciostotales: 15 | espaciostotales=int(espacios/2) 16 | espacios=-1 17 | bandera2=1 18 | elif situacion==1: 19 | for i in range(len(prueba)): 20 | if prueba[i]==".": 21 | espacios+=1 22 | if prueba[i]=="x": 23 | if espacios/2>espaciostotales and espacios%2==0: 24 | espaciostotales=int(espacios/2) 25 | elif espacios//2>espaciostotales: 26 | espaciostotales=int(espacios/2) 27 | espacios=-1 28 | elif situacion==2: 29 | for i in range(len(prueba)): 30 | if prueba[i]==".": 31 | espacios+=1 32 | if prueba[i]=="x" or i==(len(prueba))-1: 33 | if espacios>espaciostotales and i==(len(prueba))-1: 34 | espaciostotales=espacios 35 | elif espacios/2>espaciostotales and espacios%2==0: 36 | espaciostotales=int(espacios/2) 37 | elif espacios//2>espaciostotales: 38 | espaciostotales=int(espacios/2) 39 | espacios=-1 40 | else: 41 | for i in range(len(prueba)): 42 | if prueba[i]==".": 43 | espacios+=1 44 | if prueba[i]=="x": 45 | if espacios>espaciostotales and bandera2==0 : 46 | espaciostotales=espacios 47 | elif espacios/2>espaciostotales and espacios%2==0: 48 | espaciostotales=int(espacios/2) 49 | elif espacios//2>espaciostotales: 50 | espaciostotales=int(espacios/2) 51 | espacios=-1 52 | bandera2=1 53 | return espaciostotales 54 | caso=str(input()).lower() 55 | resultados = [0] * 10000 56 | i = 0 57 | while caso!="": 58 | bandera=0 59 | if caso[0]=="x" and caso[len(caso)-1]=="x": bandera=1 60 | elif caso[0]=="x": bandera=2 61 | elif caso[len(caso)-1]=="x": bandera=3 62 | resultados[i] = camasdisp(caso,bandera) 63 | i += 1 64 | caso=str(input()).lower() 65 | for i in range(i): 66 | print(resultados[i]) 67 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #15 - Volumen 1 - 197 - Mensaje interceptado/Resolución/Volumen 1 - 197 - Mensaje interceptado.py: -------------------------------------------------------------------------------- 1 | """ 2 | REFINAMIENTOS: Pág 24 final y 25 cuaderno AyED primer año 3 | 4 | Función 1 - orden(cadena): 5 | De una cadena, toma al primer caracter como el primero, el segundo como el último, el tercero como el segundo, el cuarto 6 | como el penúltimo, el quinto como el tercero, etc. 7 | Aauirnedleiua nBo → AurelianoB uednia 8 | 9 | Función 2 - img_especular(cadena): 10 | Invierte la cadena convertida entre inicio y vocal, entre vocales y entre vocal y final, manteniendo la posición de las vocales. 11 | []B[o]J ,dn[a]m[e]B s[o]dn[] → []B[o]nd, J[a]m[e]s B[o]nd[] 12 | """ 13 | 14 | def orden(cadena): 15 | cadena_referencia = cadena 16 | salida = "" 17 | auxiliar = "" 18 | for i in range(len(cadena_referencia)): 19 | if i % 2 == 0: 20 | salida = salida + cadena_referencia[i:i+1] 21 | 22 | for i in range(len(cadena_referencia)): 23 | if ((i+1) % 2) == 0: 24 | auxiliar = auxiliar + cadena_referencia[i:i+1] 25 | 26 | salida = salida + auxiliar[::-1] 27 | 28 | return salida 29 | 30 | def img_especular(cadena): 31 | cadena_referencia = cadena 32 | cadena_referencia_lower = cadena.lower() 33 | salida = "" 34 | vocales = "aeiou" 35 | 36 | contador = 1 37 | cant_vocales = 100 38 | vector_vocales = cant_vocales * [-1] 39 | 40 | #Ubicamos la posición de las vocales dentro de vector_vocales 41 | for i in range(len(cadena_referencia)): 42 | for j in range(len(vocales)): 43 | if cadena_referencia_lower[i:i+1] == vocales[j:j+1]: 44 | vector_vocales[contador] = i 45 | contador = contador + 1 46 | 47 | #Añadimos en la última posición el largo de la cadena. Esto junto a la primera posición que es 0 nos hará más fácil trabajar 48 | vector_vocales[contador] = len(cadena_referencia) 49 | 50 | #Entre los intervalos definidos dentro de vector_vocales, invertimos la cadena 51 | for i in range(cant_vocales): 52 | auxiliar = "" 53 | 54 | if i == 0: 55 | auxiliar = cadena_referencia[0:vector_vocales[1]] 56 | auxiliar = auxiliar[::-1] 57 | salida = salida + auxiliar 58 | 59 | if (i != 0) and (vector_vocales[i] != -1): 60 | auxiliar = cadena_referencia[vector_vocales[i]+1:vector_vocales[i+1]] 61 | auxiliar = auxiliar[::-1] 62 | salida = salida + cadena_referencia[vector_vocales[i]:vector_vocales[i]+1] + auxiliar 63 | 64 | return salida 65 | 66 | 67 | #ENTRADAS 68 | cadena_input = str(input()) 69 | 70 | #PROCESOS 71 | cadena_procesada = cadena_input 72 | cadena_procesada = orden(cadena_procesada) 73 | cadena_procesada = img_especular(cadena_procesada) 74 | 75 | #SALIDAS 76 | print(cadena_input, "=>",cadena_procesada) -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #1 - Espiral Galactica/EstebanAballay.py: -------------------------------------------------------------------------------- 1 | def contarestrellas(): 2 | dimension = int(input("Ingrese tamaño de matriz: ")) 3 | matriz = [[None for i in range(dimension)]for j in range(dimension)] 4 | if dimension%2==0: 5 | solucion = "La dimension no es impar..." 6 | print(solucion) 7 | return solucion 8 | 9 | 10 | for i in range(dimension): 11 | elementos = input("Ingrese los elementos de cada fila: ") 12 | for j in range(dimension): 13 | matriz[i][j] = int(elementos[j]) 14 | 15 | # Declarar variables iniciales 16 | centro = int((dimension/2) + 0.5)-1 17 | solucion = matriz[centro][centro] 18 | filas = centro 19 | columnas = centro 20 | contador = 1 21 | Flag = True 22 | 23 | 24 | while Flag and dimension%2 != 0: 25 | #Resta 1 fila, sube 26 | if filas - contador >= 0: 27 | for i in range(contador): 28 | filas -= 1 29 | solucion += matriz[filas][columnas] 30 | contador +=1 31 | else: 32 | for i in range(dimension-1): 33 | filas -= 1 34 | solucion += matriz[filas][columnas] 35 | Flag = False 36 | contador +=1 37 | 38 | #Sumo 2 columna, derecha 39 | if Flag: 40 | if columnas+contador < dimension: 41 | for i in range(contador): 42 | columnas += 1 43 | solucion += matriz[filas][columnas] 44 | contador += 1 45 | else: 46 | for i in range(columnas, dimension-1): 47 | columnas += 1 48 | solucion += matriz[filas][columnas] 49 | Flag = False 50 | contador +=1 51 | 52 | #Sumo 3 filas, abajo 53 | if Flag: 54 | if filas + contador < dimension: 55 | for i in range(contador): 56 | filas += 1 57 | solucion += matriz[filas][columnas] 58 | contador += 1 59 | else: 60 | for i in range(dimension-1): 61 | columnas += 1 62 | solucion += matriz[filas][columnas] 63 | Flag = False 64 | contador +=1 65 | 66 | 67 | #Resto 4 columnas, izquierda 68 | if Flag: 69 | if columnas - contador >= 0: 70 | for i in range(contador): 71 | columnas -= 1 72 | solucion += matriz[filas][columnas] 73 | contador +=1 74 | else: 75 | for i in range(dimension-1): 76 | columnas -= 1 77 | solucion += matriz[filas][columnas] 78 | Flag = False 79 | contador +=1 80 | 81 | print(solucion) 82 | return solucion 83 | 84 | contarestrellas() 85 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #6 - Volumen 1 - 100 - Constante de Kaprekar/Resolución/Volumen 1 - 100 - Constante de Kaprekar.py: -------------------------------------------------------------------------------- 1 | def inserción(vector,long_vector): 2 | 3 | for i in range(1,long_vector): 4 | if vector[i] < vector[i-1]: 5 | auxiliar = vector[i] 6 | vector[i] = vector[i-1] 7 | vector[i-1] = auxiliar 8 | 9 | inserción(vector,long_vector) 10 | 11 | return vector 12 | 13 | def ascendente(cadena): 14 | #Metemos cada uno de los números en un vector 15 | vector_nums = 4 * [0] 16 | for i in range(4): 17 | vector_nums[i] = num_aTrabajar[i:i+1] 18 | 19 | #Ordenamos con el método de inserción 20 | inserción(vector_nums,4) 21 | 22 | #Armamos la cadena nuevamente en base al vector ordenado 23 | ascendente = "" 24 | for i in range(4): 25 | ascendente = ascendente + str(vector_nums[i]) 26 | 27 | return ascendente 28 | 29 | 30 | #INICIALIZACIÓN DE VARIABLES 31 | vector_nums = 100*[-1] 32 | 33 | #ENTRADAS 34 | repeticiones = int(input()) 35 | 36 | for i in range(repeticiones): 37 | 38 | #INICIALIZACIÓN DE VARIABLES 39 | contador = 0 40 | invalido = 0 41 | salir = 0 42 | 43 | #ENTRADAS 44 | num_ingresado = str(input()) 45 | num_aTrabajar = num_ingresado 46 | 47 | #PROCESOS 48 | 49 | #Confirmamos que el número sea de 4 dígitos 50 | if len(num_aTrabajar) == 4: 51 | 52 | if num_aTrabajar == "6174": 53 | vector_nums[i] = contador 54 | else: 55 | #Confirmamos que el número esté formado por al menos 2 dígitos distintos 56 | if num_aTrabajar[0:1] == num_aTrabajar[1:2] and num_aTrabajar[0:1] == num_aTrabajar[2:3] and num_aTrabajar[0:1] == num_aTrabajar[3:4]: 57 | invalido = 1 58 | 59 | if invalido == 0: 60 | 61 | while salir == 0: 62 | contador = contador + 1 63 | #Ahora que verificamos los 4 dígitos los ordenamos en orden ascendente 64 | num_ascendente = ascendente(num_aTrabajar) 65 | #Invertimos a ascendente para obtener descendente 66 | num_descendiente = num_ascendente[::-1] 67 | 68 | resta = str(int(num_descendiente) - int(num_ascendente)) 69 | 70 | if resta == "6174": 71 | vector_nums[i] = contador 72 | salir = 1 73 | 74 | if len(resta) == 3: 75 | resta = "0"+resta 76 | 77 | if len(resta) == 2: 78 | resta = "00"+resta 79 | 80 | if len(resta) == 1: 81 | resta = "000"+resta 82 | 83 | num_aTrabajar = resta 84 | 85 | vector_nums[i] = contador 86 | else: 87 | vector_nums[i] = 8 88 | else: 89 | print("ERROR: Ingrese un número de 4 dígitos") 90 | 91 | #SALIDAS 92 | for i in range(100): 93 | if vector_nums[i] != -1: 94 | print(vector_nums[i]) -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #9 - Volumen 1 - 151 - Es matriz identidad/Resolución/Volumen 1 - 151 - Es matriz identidad.py: -------------------------------------------------------------------------------- 1 | def split(cadena,sep): 2 | 3 | largo_vector = 100 4 | vector_salida = [None] * largo_vector 5 | vector_pos_sep = [None] * largo_vector 6 | cont_pos = -1 7 | 8 | #Buscamos las posiciones del carácter sep 9 | for i in range(len(cadena)): 10 | if cadena[i : i+1] == sep: 11 | cont_pos = cont_pos + 1 12 | vector_pos_sep[cont_pos] = i 13 | 14 | #Los intervalos dentro de vector_pos_sep nos definen palabras, separadas por sep 15 | if cont_pos != -1: #Si el usuario ingresó un sep que no está en cadena, no procesamos nada. 16 | 17 | cont_pos = 0 18 | 19 | for i in range(largo_vector): 20 | if vector_pos_sep[i] != None: 21 | 22 | if i == 0: 23 | vector_salida[cont_pos] = int(cadena[0: vector_pos_sep[cont_pos]]) 24 | 25 | else: 26 | vector_salida[cont_pos + 1] = int(cadena[vector_pos_sep[cont_pos] + 1 : vector_pos_sep[cont_pos + 1]]) 27 | cont_pos = cont_pos + 1 28 | 29 | else: #Completamos el último elemento del vector con una subcadena que va desde el elemento siguiente al último sep hasta el final de la cadena. 30 | vector_salida[cont_pos + 1] = int(cadena[vector_pos_sep[cont_pos] + 1 : len(cadena)]) 31 | 32 | return vector_salida 33 | 34 | 35 | #INICIALIZACIÓN DE VARIABLES 36 | salir = 0 37 | vector_salida = 100 * [""] 38 | contador = 0 39 | 40 | while salir == 0: 41 | dimension = int(input()) 42 | 43 | if dimension == 0: 44 | salir = 1 45 | else: 46 | #Definimos una matriz cuadrada, que llenará el usuario 47 | matriz_usuario = [[int(0) for ind0 in range(dimension)] for ind1 in range(dimension)] 48 | matriz_identidad = [[int(0) for ind0 in range(dimension)] for ind1 in range(dimension)] 49 | #Definimos una matriz identidad 50 | for i in range(dimension): 51 | for j in range(dimension): 52 | if i == j: 53 | matriz_identidad[i][j] = 1 54 | 55 | #Permitimos que el usuario llene a matriz_usuario con datos 56 | for num_fila in range(dimension): 57 | elementos_fila = str(input()) 58 | 59 | #Utilizamos la función split para aislar los elementos de esta cadena en un vector 60 | vector_elementos_fila = split(elementos_fila," ") 61 | 62 | #Vertemos los elementos de este vector en matriz_usuario 63 | for i in range(dimension): 64 | if vector_elementos_fila[i] != None: 65 | matriz_usuario[num_fila][i] = vector_elementos_fila[i] 66 | 67 | #Comparamos la matriz ingresada por el usuario con la identidad. Si son iguales escribimos si, caso contrario no 68 | if matriz_usuario == matriz_identidad: 69 | vector_salida[contador] = "SI" 70 | else: 71 | vector_salida[contador] = "NO" 72 | 73 | contador = contador + 1 74 | 75 | for i in range(100): 76 | if vector_salida[i] != "": 77 | print(vector_salida[i],end = "\n") -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #3 - Cadenas ADN/Resolucion/resolucionProfes.py: -------------------------------------------------------------------------------- 1 | """ 2 | ENTRADA 3 | 4 | La entrada estara formada por distintos casos de prueba. Cada uno comienza con una linea que 5 | indica el numero de cadenas de ADN que se daran (hasta 40.000). A continuacion vendra una linea con 6 | cada una de las cadenas, todas con la misma longitud (como mucho 50 caracteres). 7 | Cada cadena de ADN tendra los caracteres A, C, G y T indicando el nucleotido colocado en esa 8 | posicion o un guion (-) indicando un hueco (nucleotido desconocido) en la cadena. De haber huecos o 9 | guiones estos estaran colocados principalmente en los laterales de la cadena; en la parte central nunca 10 | habra mas de 2. 11 | Dos cadenas pueden pertenecer al mismo individuo si en las posiciones en las que ambas tienen 12 | nucleotido conocido, este coincide. 13 | 14 | SALIDA 15 | 16 | Por cada caso de prueba se escribira una linea con tantos numeros como cadenas de ADN se han 17 | dado. El numero en la posicion i indicara cuantas cadenas iguales a la cadena colocada en la posicion i 18 | hay (sin contar a ella misma), teniendo en cuenta que los guiones se consideran igual a cualquier otro 19 | nucleotido (o a otro guion) 20 | """ 21 | 22 | casos = 1 23 | salida = [] 24 | while casos > 0: 25 | casos = int(input()) 26 | if casos != 0: 27 | vectorCadenas = [""] * casos 28 | 29 | #Recepción de cadenas 30 | for i in range(casos): 31 | vectorCadenas[i] = input() 32 | 33 | #Averigüo cantidad de símbolos de las cadenas 34 | cantidadSimbolos = len(vectorCadenas[0]) 35 | 36 | #Creo la matriz para almacenar los caracteres 37 | matriz = [[' ' for _ in range(cantidadSimbolos)] for _ in range(casos)] 38 | 39 | #Cargo la matriz con los caracteres 40 | for i in range(casos): 41 | cadena = vectorCadenas[i] 42 | for j in range(cantidadSimbolos): 43 | matriz[i][j] = cadena[j] 44 | 45 | #Análisis 46 | vectorResultados = [0] * casos 47 | vectorVerificaciones = [False] * casos #Si es False, es porque en esa fila/cadena, no se encontró diferencias todavía 48 | resultado = casos - 1 49 | for k in range(casos): # Elegir la fila donde pivotamos, y a partir de esa comparamos 50 | for i in range(cantidadSimbolos): 51 | simbolo = matriz[k][i] 52 | #Si es un -, es comodín y anda con cualquiera. Si es diferente a -, hay que analizar. 53 | if simbolo != "-": 54 | for j in range(casos): 55 | #Si k y j son iguales significa que compararía con la misma fila en la que estoy parado 56 | if k != j: 57 | simbolo2 = matriz[j][i] 58 | if simbolo != simbolo2 and vectorVerificaciones[j] == False and simbolo2 != "-": 59 | resultado -= 1 60 | vectorVerificaciones[j] = True 61 | vectorResultados[k] = resultado 62 | resultado = casos - 1 63 | vectorVerificaciones = [False] * casos 64 | 65 | salida.append(vectorResultados) 66 | 67 | for i in range(len(salida)): 68 | for j in range(len(salida[i])): 69 | print(salida[i][j], end = " ") 70 | print("") -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #14 - Volumen 1 - 176 - Campo de Minas/Resolución/Volumen 1 - 176 - Campo de Minas.py: -------------------------------------------------------------------------------- 1 | def ubi_espacio(dimensiones): 2 | espacio = -1 3 | for i in range(len(dimensiones)): 4 | if dimensiones[i:i+1] == " ": 5 | espacio = i 6 | 7 | return espacio 8 | 9 | def verif_fila(cadena): 10 | valido = True 11 | for i in range(len(cadena)): 12 | if cadena[i:i+1] != "*" and cadena[i:i+1] != "-": 13 | valido = False 14 | 15 | return valido 16 | 17 | def verif_dimension(dimensiones,espacio): 18 | valido = True 19 | for i in range(espacio): 20 | if dimensiones[i:i+1] != "0" and dimensiones[i:i+1] != "1" and dimensiones[i:i+1] != "2" and dimensiones[i:i+1] != "3" and dimensiones[i:i+1] != "4" and dimensiones[i:i+1] != "5" and dimensiones[i:i+1] != "6" and dimensiones[i:i+1] != "7" and dimensiones[i:i+1] != "8" and dimensiones[i:i+1] != "9": 21 | valido = False 22 | 23 | if valido == True: 24 | for i in range(espacio+1,len(dimensiones)): 25 | if dimensiones[i:i+1] != "0" and dimensiones[i:i+1] != "1" and dimensiones[i:i+1] != "2" and dimensiones[i:i+1] != "3" and dimensiones[i:i+1] != "4" and dimensiones[i:i+1] != "5" and dimensiones[i:i+1] != "6" and dimensiones[i:i+1] != "7" and dimensiones[i:i+1] != "8" and dimensiones[i:i+1] != "9": 26 | valido = False 27 | 28 | return valido 29 | 30 | 31 | #INICIALIZACIÓN DE VARIABLES 32 | invalido = 0 33 | contador = 0 34 | vacias_con6minas = 0 35 | 36 | #E N T R A D A S 37 | dimensiones = str(input("Ingrese las dimensiones: ")) #Se ingresa ancho x alto 38 | 39 | while ubi_espacio(dimensiones) == -1: 40 | dimensiones = str(input("ERROR - Reingrese las dimensiones: ")) 41 | 42 | if ubi_espacio(dimensiones) != -1: 43 | while (verif_dimension(dimensiones,ubi_espacio(dimensiones)) == False): 44 | dimensiones = str(input("ERROR - Reingrese las dimensiones: ")) 45 | 46 | espacio = ubi_espacio(dimensiones) 47 | ancho = int(dimensiones[0:espacio]) 48 | alto = int(dimensiones[espacio+1 : len(dimensiones)]) 49 | 50 | #Definimos una matriz del tamaño ancho x alto 51 | matriz = [[str("0") for ind0 in range(ancho)] for ind1 in range(alto)] 52 | 53 | for i in range(alto): 54 | #Permitimos que el usuario ingrese una cadena de longitud ancho, que colocaremos en la primer fila de matriz 55 | cadena = str(input("Ingrese la fila: ")) 56 | 57 | while (verif_fila(cadena) == False) or (len(cadena) != ancho): 58 | cadena = str(input("ERROR - Ingrese la fila nuevamente: ")) 59 | 60 | #Pasamos la cadena a la posición respectiva en la matriz 61 | for j in range(ancho): 62 | matriz[i][j] = cadena[j:j+1] 63 | 64 | #P R O C E S O S 65 | 66 | #Encontramos una celda vacía que no esté en los bordes de la matriz, ya que como max estas pueden estar rodeadas por 5 * 67 | for i in range(1,alto-1): 68 | for j in range(1,ancho-1): 69 | if matriz[i][j] == "-": 70 | #Una vez encontramos una posición con un -, recorremos un espacio 3x3 en su alrededor, y contamos cada vez que aparezca un * 71 | for k in range(i-1,i+2): 72 | for l in range(j-1,j+2): 73 | if matriz[k][l] == "*": 74 | contador = contador + 1 75 | 76 | if contador >= 6: 77 | vacias_con6minas = vacias_con6minas + 1 78 | contador = 0 79 | 80 | #S A L I D A S 81 | print("------------------------------") 82 | print("Celdas vacías rodeadas por 6 o más minas:",vacias_con6minas) 83 | print("------------------------------") 84 | print("MATRIZ INGRESADA") 85 | print("------------------------------") 86 | for i in range(alto): 87 | for j in range(ancho): 88 | print(matriz[i][j],end = " ") 89 | print("",end = "\n") 90 | print("------------------------------") 91 | 92 | -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #1 - Espiral Galactica/Resolucion/resoluciónProfes.py: -------------------------------------------------------------------------------- 1 | def contadorEstrellas(matriz, dimension): 2 | bandera = False 3 | contador = 1 4 | estrellas = 0 5 | columna = int((dimension - 1) / 2) 6 | fila = columna 7 | while bandera == False: 8 | # Movimiento arriba: Decremento fila i y mantengo columna j 9 | if fila - contador + 1>= 0: 10 | if contador != 1: 11 | for i in range(fila, fila - contador, -1): 12 | estrellas += int(matriz[i][columna]) 13 | fila = fila - contador +1 14 | contador += 1 15 | columna = columna + 1 16 | else: 17 | for i in range(fila, fila - contador - 1, -1): 18 | estrellas += int(matriz[i][columna]) 19 | fila = fila - contador 20 | contador += 1 21 | columna = columna + 1 22 | else: 23 | for i in range(fila, -1, -1): 24 | estrellas += int(matriz[i][columna]) 25 | break 26 | 27 | # Movimiento derecha: Mantengo i e incremento j 28 | if (columna + contador - 1) <= (dimension - 1): 29 | for i in range(columna, columna + contador): 30 | estrellas += int(matriz[fila][i]) 31 | columna = columna + contador -1 32 | contador += 1 33 | fila += 1 34 | else: 35 | for i in range(columna, dimension): 36 | estrellas += int(matriz[fila][i]) 37 | break 38 | 39 | # Movimiento abajo: Incremento i y mantengo j 40 | if (fila + contador - 1) < dimension: 41 | for i in range(fila, fila + contador): 42 | estrellas += int(matriz[i][columna]) 43 | fila = fila + contador - 1 44 | columna -= 1 45 | contador += 1 46 | else: 47 | for i in range(fila, dimension): 48 | estrellas += int(matriz[i][columna]) 49 | break 50 | 51 | # Movimiento izquierda: Mantengo i y decremento j 52 | if (columna - contador + 1) > -1: 53 | for i in range(columna, columna - contador, -1): 54 | estrellas += int(matriz[fila][i]) 55 | columna = columna - contador + 1 56 | fila -= 1 57 | contador += 1 58 | else: 59 | for i in range(columna, -1, -1): 60 | estrellas += int(matriz[fila][i]) 61 | break 62 | return estrellas 63 | 64 | def separarNumeros(cadena): 65 | nums = 0 66 | for i in range(len(cadena)): 67 | if cadena[i] == " " or i == len(cadena) - 1: 68 | nums += 1 69 | vector = [""] * nums 70 | indice = 0 71 | for i in range(len(cadena)): 72 | if cadena[i] != " ": 73 | vector[indice] += cadena[i] 74 | if cadena[i] == " " or i == (len(cadena) - 1): 75 | indice += 1 76 | return vector 77 | 78 | vectorResultados = [-1] * 1000 79 | dimension = 1 80 | indice = 0 81 | while dimension > 0: 82 | dimension = int(input()) 83 | if dimension != 0: 84 | matriz = [] 85 | for i in range(dimension): 86 | matriz.append(separarNumeros(input())) 87 | vectorResultados[indice] = contadorEstrellas(matriz, dimension) 88 | indice += 1 89 | for i in range(1000): 90 | if vectorResultados[i] != -1: 91 | print(vectorResultados[i]) 92 | 93 | """ 94 | 95 | EJEMPLOS 96 | matriz = [[2,4,4,4,4],[2,3,3,4,5],[5,2,2,7,1],[2,1,3,5,3],[2,4,3,1,2]] 97 | matriz = [[3,3,4],[2,2,7],[1,3,5]] 98 | matriz = [[2,1,2,2,3,2,3],[4,2,4,4,4,4,4],[3,2,3,3,4,5,3],[4,5,2,2,7,1,2],[5,2,1,3,5,3,6],[4,2,4,3,1,2,0],[3,9,9,9,9,2,9]] 99 | 100 | """ -------------------------------------------------------------------------------- /Ejercicios/Ejercicio #3 - Cadenas ADN/Resolucion/Resolución cadenas ADN sin append + paso a paso + comentarios.py: -------------------------------------------------------------------------------- 1 | #INICIALIZACIÓN DE VARIABLES 2 | salida = 0 3 | contador_filas_matriz = -1 4 | 5 | #Generamos una matriz, cuyas columnas representan una cadena, y las filas indican las distintas iteraciones del algoritmo realizadas. 6 | #Se sobredimensiona, originalmente se planteó con 20x20 7 | filas = 5 8 | columnas = 5 9 | matriz = [[int(-1) for ind0 in range(columnas)] for ind1 in range(filas)] 10 | 11 | while salida == 0: 12 | #INICIALIZACIÓN DE VARIABLES 13 | contador_iguales = 0 14 | 15 | #ENTRADAS 16 | #Le pedimos al usuario que ingrese la cantidad de cadenas a analizar 17 | cant_cadenas = int(input()) 18 | 19 | if cant_cadenas != 0: 20 | #INICIALIZACIÓN DE VARIABLES - Contadores 21 | vector_cadenas_ADN = [0] * cant_cadenas 22 | contador_filas_matriz = contador_filas_matriz + 1 #Este contador cambia de fila la matriz para cada intento nuevo 23 | 24 | #ENTRADAS 25 | #Le pedimos al usuario que ingrese cada una de las cadenas dentro del vector 26 | for i in range(cant_cadenas): 27 | vector_cadenas_ADN[i] = str(input()) 28 | 29 | #PROCESOS 30 | print("vector =",vector_cadenas_ADN) 31 | #Recorremos el vector posición por posición. 32 | for i in range(cant_cadenas): 33 | contador_iguales = 0 34 | for j in range(cant_cadenas): 35 | #Comparamos la posición actual con el resto (no comparamos con ella misma) 36 | if j != i: 37 | 38 | iguales = True 39 | cadena1 = str(vector_cadenas_ADN[i]) 40 | cadena2 = str(vector_cadenas_ADN[j]) 41 | 42 | print("comparando",cadena1,"con",cadena2) 43 | 44 | #Recorremos cadena1 y cadena2 elemento por elemento, y comparamos las posiciones homólogas. Si son distintas, 45 | #verificamos si alguna de las 2 es un guión, caso en el que damos a las posiciones como iguales. 46 | #Si en algún momento la comparación nos da distinta; no sumamos 1 a contador_iguales. Si da igual, sumamos 1 47 | 48 | for k in range(len(cadena1)): 49 | #Compararemos siempre y cuando todos los elementos analizados sean iguales 50 | if iguales == True: 51 | #Si son dos elementos iguales, no hace falta comparar más 52 | if cadena1[k : k + 1] == cadena2 [k : k+1]: 53 | print("caracter1 =",cadena1[k:k+1],"caracter2",cadena2[k:k+1]) 54 | iguales = True 55 | print("iguales =",iguales) 56 | #Si uno de los elementos es un guión, damos la comparación como válida 57 | elif cadena1[k : k +1] == "-" or cadena2[k : k+1] == "-": 58 | print("caracter1 =",cadena1[k:k+1],"caracter2",cadena2[k:k+1]) 59 | iguales = True 60 | print("iguales =",iguales) 61 | #Si no se cumple ninguna de las anteriores, damos la comparación como negativa 62 | elif cadena1[k : k+1] != cadena2 [k : k+1]: 63 | print("caracter1 =",cadena1[k:k+1],"caracter2",cadena2[k:k+1]) 64 | iguales = False 65 | print("iguales =",iguales) 66 | 67 | #Si al terminar el ciclo for, iguales es True, significa que las cadenas analizadas son iguales; por lo que añadimos 68 | #1 a contador_iguales 69 | 70 | if iguales == True: 71 | print("IGUALES") 72 | contador_iguales = contador_iguales + 1 73 | else: 74 | print("DISTINTOS") 75 | iguales == True 76 | 77 | print("\n") 78 | 79 | #Al terminar de ciclar por todas las posibilidades j de i; colocamos el valor de contador_iguales en la matriz 80 | print("contador",i,"=",contador_iguales) 81 | print("fila=",contador_filas_matriz) 82 | matriz[contador_filas_matriz][i] = contador_iguales 83 | print("-----------------------") 84 | else: 85 | salida = 1 86 | 87 | #SALIDAS 88 | #Imprimimos la matriz con todos los resultados 89 | print("contador filas =",contador_filas_matriz) 90 | for i in range(filas): 91 | for j in range(columnas): 92 | #Imprimimos todos los elementos que no sean -1 93 | if matriz[i][j] != (-1): 94 | print(matriz[i][j],end = " ") 95 | if i <= contador_filas_matriz: 96 | print("",end = "\n") 97 | 98 | print(matriz) -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Apache License 2 | Version 2.0, January 2004 3 | http://www.apache.org/licenses/ 4 | 5 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 6 | 7 | 1. Definitions. 8 | 9 | "License" shall mean the terms and conditions for use, reproduction, 10 | and distribution as defined by Sections 1 through 9 of this document. 11 | 12 | "Licensor" shall mean the copyright owner or entity authorized by 13 | the copyright owner that is granting the License. 14 | 15 | "Legal Entity" shall mean the union of the acting entity and all 16 | other entities that control, are controlled by, or are under common 17 | control with that entity. For the purposes of this definition, 18 | "control" means (i) the power, direct or indirect, to cause the 19 | direction or management of such entity, whether by contract or 20 | otherwise, or (ii) ownership of fifty percent (50%) or more of the 21 | outstanding shares, or (iii) beneficial ownership of such entity. 22 | 23 | "You" (or "Your") shall mean an individual or Legal Entity 24 | exercising permissions granted by this License. 25 | 26 | "Source" form shall mean the preferred form for making modifications, 27 | including but not limited to software source code, documentation 28 | source, and configuration files. 29 | 30 | "Object" form shall mean any form resulting from mechanical 31 | transformation or translation of a Source form, including but 32 | not limited to compiled object code, generated documentation, 33 | and conversions to other media types. 34 | 35 | "Work" shall mean the work of authorship, whether in Source or 36 | Object form, made available under the License, as indicated by a 37 | copyright notice that is included in or attached to the work 38 | (an example is provided in the Appendix below). 39 | 40 | "Derivative Works" shall mean any work, whether in Source or Object 41 | form, that is based on (or derived from) the Work and for which the 42 | editorial revisions, annotations, elaborations, or other modifications 43 | represent, as a whole, an original work of authorship. For the purposes 44 | of this License, Derivative Works shall not include works that remain 45 | separable from, or merely link (or bind by name) to the interfaces of, 46 | the Work and Derivative Works thereof. 47 | 48 | "Contribution" shall mean any work of authorship, including 49 | the original version of the Work and any modifications or additions 50 | to that Work or Derivative Works thereof, that is intentionally 51 | submitted to Licensor for inclusion in the Work by the copyright owner 52 | or by an individual or Legal Entity authorized to submit on behalf of 53 | the copyright owner. For the purposes of this definition, "submitted" 54 | means any form of electronic, verbal, or written communication sent 55 | to the Licensor or its representatives, including but not limited to 56 | communication on electronic mailing lists, source code control systems, 57 | and issue tracking systems that are managed by, or on behalf of, the 58 | Licensor for the purpose of discussing and improving the Work, but 59 | excluding communication that is conspicuously marked or otherwise 60 | designated in writing by the copyright owner as "Not a Contribution." 61 | 62 | "Contributor" shall mean Licensor and any individual or Legal Entity 63 | on behalf of whom a Contribution has been received by Licensor and 64 | subsequently incorporated within the Work. 65 | 66 | 2. Grant of Copyright License. Subject to the terms and conditions of 67 | this License, each Contributor hereby grants to You a perpetual, 68 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 69 | copyright license to reproduce, prepare Derivative Works of, 70 | publicly display, publicly perform, sublicense, and distribute the 71 | Work and such Derivative Works in Source or Object form. 72 | 73 | 3. Grant of Patent License. Subject to the terms and conditions of 74 | this License, each Contributor hereby grants to You a perpetual, 75 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 76 | (except as stated in this section) patent license to make, have made, 77 | use, offer to sell, sell, import, and otherwise transfer the Work, 78 | where such license applies only to those patent claims licensable 79 | by such Contributor that are necessarily infringed by their 80 | Contribution(s) alone or by combination of their Contribution(s) 81 | with the Work to which such Contribution(s) was submitted. If You 82 | institute patent litigation against any entity (including a 83 | cross-claim or counterclaim in a lawsuit) alleging that the Work 84 | or a Contribution incorporated within the Work constitutes direct 85 | or contributory patent infringement, then any patent licenses 86 | granted to You under this License for that Work shall terminate 87 | as of the date such litigation is filed. 88 | 89 | 4. Redistribution. You may reproduce and distribute copies of the 90 | Work or Derivative Works thereof in any medium, with or without 91 | modifications, and in Source or Object form, provided that You 92 | meet the following conditions: 93 | 94 | (a) You must give any other recipients of the Work or 95 | Derivative Works a copy of this License; and 96 | 97 | (b) You must cause any modified files to carry prominent notices 98 | stating that You changed the files; and 99 | 100 | (c) You must retain, in the Source form of any Derivative Works 101 | that You distribute, all copyright, patent, trademark, and 102 | attribution notices from the Source form of the Work, 103 | excluding those notices that do not pertain to any part of 104 | the Derivative Works; and 105 | 106 | (d) If the Work includes a "NOTICE" text file as part of its 107 | distribution, then any Derivative Works that You distribute must 108 | include a readable copy of the attribution notices contained 109 | within such NOTICE file, excluding those notices that do not 110 | pertain to any part of the Derivative Works, in at least one 111 | of the following places: within a NOTICE text file distributed 112 | as part of the Derivative Works; within the Source form or 113 | documentation, if provided along with the Derivative Works; or, 114 | within a display generated by the Derivative Works, if and 115 | wherever such third-party notices normally appear. The contents 116 | of the NOTICE file are for informational purposes only and 117 | do not modify the License. You may add Your own attribution 118 | notices within Derivative Works that You distribute, alongside 119 | or as an addendum to the NOTICE text from the Work, provided 120 | that such additional attribution notices cannot be construed 121 | as modifying the License. 122 | 123 | You may add Your own copyright statement to Your modifications and 124 | may provide additional or different license terms and conditions 125 | for use, reproduction, or distribution of Your modifications, or 126 | for any such Derivative Works as a whole, provided Your use, 127 | reproduction, and distribution of the Work otherwise complies with 128 | the conditions stated in this License. 129 | 130 | 5. Submission of Contributions. Unless You explicitly state otherwise, 131 | any Contribution intentionally submitted for inclusion in the Work 132 | by You to the Licensor shall be under the terms and conditions of 133 | this License, without any additional terms or conditions. 134 | Notwithstanding the above, nothing herein shall supersede or modify 135 | the terms of any separate license agreement you may have executed 136 | with Licensor regarding such Contributions. 137 | 138 | 6. Trademarks. This License does not grant permission to use the trade 139 | names, trademarks, service marks, or product names of the Licensor, 140 | except as required for reasonable and customary use in describing the 141 | origin of the Work and reproducing the content of the NOTICE file. 142 | 143 | 7. Disclaimer of Warranty. Unless required by applicable law or 144 | agreed to in writing, Licensor provides the Work (and each 145 | Contributor provides its Contributions) on an "AS IS" BASIS, 146 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 147 | implied, including, without limitation, any warranties or conditions 148 | of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A 149 | PARTICULAR PURPOSE. You are solely responsible for determining the 150 | appropriateness of using or redistributing the Work and assume any 151 | risks associated with Your exercise of permissions under this License. 152 | 153 | 8. Limitation of Liability. In no event and under no legal theory, 154 | whether in tort (including negligence), contract, or otherwise, 155 | unless required by applicable law (such as deliberate and grossly 156 | negligent acts) or agreed to in writing, shall any Contributor be 157 | liable to You for damages, including any direct, indirect, special, 158 | incidental, or consequential damages of any character arising as a 159 | result of this License or out of the use or inability to use the 160 | Work (including but not limited to damages for loss of goodwill, 161 | work stoppage, computer failure or malfunction, or any and all 162 | other commercial damages or losses), even if such Contributor 163 | has been advised of the possibility of such damages. 164 | 165 | 9. Accepting Warranty or Additional Liability. While redistributing 166 | the Work or Derivative Works thereof, You may choose to offer, 167 | and charge a fee for, acceptance of support, warranty, indemnity, 168 | or other liability obligations and/or rights consistent with this 169 | License. However, in accepting such obligations, You may act only 170 | on Your own behalf and on Your sole responsibility, not on behalf 171 | of any other Contributor, and only if You agree to indemnify, 172 | defend, and hold each Contributor harmless for any liability 173 | incurred by, or claims asserted against, such Contributor by reason 174 | of your accepting any such warranty or additional liability. 175 | 176 | END OF TERMS AND CONDITIONS 177 | 178 | APPENDIX: How to apply the Apache License to your work. 179 | 180 | To apply the Apache License to your work, attach the following 181 | boilerplate notice, with the fields enclosed by brackets "[]" 182 | replaced with your own identifying information. (Don't include 183 | the brackets!) The text should be enclosed in the appropriate 184 | comment syntax for the file format. We also recommend that a 185 | file or class name and description of purpose be included on the 186 | same "printed page" as the copyright notice for easier 187 | identification within third-party archives. 188 | 189 | Copyright [yyyy] [name of copyright owner] 190 | 191 | Licensed under the Apache License, Version 2.0 (the "License"); 192 | you may not use this file except in compliance with the License. 193 | You may obtain a copy of the License at 194 | 195 | http://www.apache.org/licenses/LICENSE-2.0 196 | 197 | Unless required by applicable law or agreed to in writing, software 198 | distributed under the License is distributed on an "AS IS" BASIS, 199 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 200 | See the License for the specific language governing permissions and 201 | limitations under the License. 202 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Ejercicios de lógica y programación - Taller de acompañamiento de algoritmos 🐍 2 | 3 | ¡Bienvenido al repositorio "ejercicios-curso-python"! Aquí podrás compartir y colaborar en las resoluciones de los desafíos propuestos durante el "TALLER DE ACOMPAÑAMIENTO ACADÉMICO ALGORITMOS Y ESTRUCTURAS DE DATOS" dictado en la UTN-FRVM. 4 | 5 | ## Objetivos del taller 🚀 6 | 7 | 1. Reforzar los conceptos de pensamiento computacional, lógica computacional y algoritmos. 8 | 2. Cultivar el espíritu de colaboración y trabajo en equipo a través de proyectos prácticos que involucren el uso de Python y la manipulación de estructuras de datos. 9 | 3. Capacitar a los estudiantes en el uso efectivo del lenguaje de programación Python como una herramienta versátil para implementar soluciones en código. 10 | 4. Incentivar el pensamiento crítico y la capacidad de abstracción al plantear desafíos que requieran análisis y diseño de soluciones algorítmicas. 11 | 12 | ## Información importante 13 | 14 | * Cada clase se publica un nuevo ejercicio. 15 | * Los ejercicios no tienen relación entre ellos. Puedes resolverlos de manera totalmente independiente. 16 | * Una vez se haya cumplido la semana de publicación del ejercicio, podrás consultar nuestra solución y las de los demas estudiantes. 17 | 18 | ## Listado de ejercicios 19 | Aca podrás encontrar el listado de los ejercicios, su fecha de publicación y enunciado del mismo. En su directorio podrás consultar las distintas correcciones del ejercicio. 20 | 21 | !) NOTA: Si no funciona el visualizador de PDF de Github, descargar el archivo. 22 | 23 | * #0 - 06/11/23 | [MATRICES TRIANGULARES](https://github.com/vterreno/ejercicios-curso-python/blob/main/Ejercicios/Ejercicio%20%230%20-%20Matrices%20Triangulares/enunciado.pdf) | Correcciones: [[SOLUCIÓN]](https://github.com/vterreno/ejercicios-curso-python/tree/main/Ejercicios/Ejercicio%20%230%20-%20Matrices%20Triangulares/Resoluciony) [[ALUMNOS]](https://github.com/vterreno/ejercicios-curso-python/tree/main/Ejercicios/Ejercicio%20%230%20-%20Matrices%20Triangulares) 24 | * #1 - 13/11/23 | [ESPIRAL GALACTICA](https://github.com/vterreno/ejercicios-curso-python/blob/main/Ejercicios/Ejercicio%20%231%20-%20Espiral%20Galactica/enunciado.pdf) | Correcciones: [[SOLUCIÓN]](https://github.com/vterreno/ejercicios-curso-python/tree/main/Ejercicios/Ejercicio%20%231%20-%20Espiral%20Galactica/Resolucion) [[ALUMNOS]](https://github.com/vterreno/ejercicios-curso-python/tree/main/Ejercicios/Ejercicio%20%231%20-%20Espiral%20Galactica) 25 | * #2 - 13/11/23 | [BUSCAMINAS](https://github.com/vterreno/ejercicios-curso-python/blob/main/Ejercicios/Ejercicio%20%232%20-%20Buscaminas/enunciado.pdf) | Correcciones: [[SOLUCIÓN]](https://github.com/vterreno/ejercicios-curso-python/tree/main/Ejercicios/Ejercicio%20%232%20-%20Buscaminas/Resolucion) [[ALUMNOS]](https://github.com/vterreno/ejercicios-curso-python/tree/main/Ejercicios/Ejercicio%20%232%20-%20Buscaminas) 26 | * #3 - 13/11/23 | [CADENASADN](https://github.com/vterreno/ejercicios-curso-python/blob/main/Ejercicios/Ejercicio%20%233%20-%20Cadenas%20ADN/enunciado.pdf) | Correcciones: [[SOLUCIÓN]](https://github.com/vterreno/ejercicios-curso-python/tree/main/Ejercicios/Ejercicio%20%233%20-%20Cadenas%20ADN/Resolucion) [[ALUMNOS]](https://github.com/vterreno/ejercicios-curso-python/tree/main/Ejercicios/Ejercicio%20%233%20-%20Cadenas%20ADN) 27 | * #4 - 13/11/23 | [DIAMANTESYARENA](https://github.com/vterreno/ejercicios-curso-python/blob/main/Ejercicios/Ejercicio%20%234%20-%20Diamantes%20y%20Arena/enunciado.pdf) | Correcciones: [[SOLUCIÓN]](https://github.com/vterreno/ejercicios-curso-python/tree/main/Ejercicios/Ejercicio%20%234%20-%20Diamantes%20y%20Arena/Resolucion) [[ALUMNOS]](https://github.com/vterreno/ejercicios-curso-python/tree/main/Ejercicios/Ejercicio%20%234%20-%20Diamantes%20y%20Arena) 28 | * #5 - 15/11/23 | [TIEMPODELEVENTO](https://github.com/vterreno/ejercicios-curso-python/blob/main/Ejercicios/Ejercicio%20%235%20-%20Tiempo%20del%20evento/enunciado.pdf) | Correcciones: [SOLUCIÓN] [[ALUMNOS]](https://github.com/vterreno/ejercicios-curso-python/tree/main/Ejercicios/Ejercicio%20%235%20-%20Tiempo%20del%20evento) 29 | * #6 - 28/09/23 | [CONSTANTE-KAPREKAR](https://github.com/vterreno/ejercicios-curso-python/blob/main/Ejercicios/Ejercicio%20%236%20-%20Volumen%201%20-%20100%20-%20Constante%20de%20Kaprekar/Volumen%201%20-%20100%20-%20Constante%20de%20Kaprekar.pdf) | Correcciones: [SOLUCIÓN](https://github.com/vterreno/ejercicios-curso-python/tree/main/Ejercicios/Ejercicio%20%236%20-%20Volumen%201%20-%20100%20-%20Constante%20de%20Kaprekar/Resoluci%C3%B3n) [[ALUMNOS]](https://github.com/vterreno/ejercicios-curso-python/tree/main/Ejercicios/Ejercicio%20%236%20-%20Volumen%201%20-%20100%20-%20Constante%20de%20Kaprekar) 30 | * #7 - 28/09/23 | [APROXIMACIÓN-GAUSS](https://github.com/vterreno/ejercicios-curso-python/blob/main/Ejercicios/Ejercicio%20%237%20-%20Volumen%201%20-%20107%20-%20Aproximaci%C3%B3n%20de%20gauss/Volumen%201%20-%20107%20-%20Aproximaci%C3%B3n%20de%20gauss.pdf) | Correcciones: [SOLUCIÓN](https://github.com/vterreno/ejercicios-curso-python/tree/main/Ejercicios/Ejercicio%20%237%20-%20Volumen%201%20-%20107%20-%20Aproximaci%C3%B3n%20de%20gauss/Resoluci%C3%B3n) [[ALUMNOS]](https://github.com/vterreno/ejercicios-curso-python/tree/main/Ejercicios/Ejercicio%20%237%20-%20Volumen%201%20-%20107%20-%20Aproximaci%C3%B3n%20de%20gauss) 31 | * #8 - 28/09/23 | [NOCHEVIEJA](https://github.com/vterreno/ejercicios-curso-python/blob/main/Ejercicios/Ejercicio%20%238%20-%20Volumen%201%20-%20148%20-%20Nochevieja/Volumen%201%20-%20148%20-%20Nochevieja.pdf) | Correcciones: [SOLUCIÓN](https://github.com/vterreno/ejercicios-curso-python/tree/main/Ejercicios/Ejercicio%20%238%20-%20Volumen%201%20-%20148%20-%20Nochevieja/Resoluci%C3%B3n) [[ALUMNOS]](https://github.com/vterreno/ejercicios-curso-python/tree/main/Ejercicios/Ejercicio%20%238%20-%20Volumen%201%20-%20148%20-%20Nochevieja) 32 | * #9 - 28/09/23 | [ES-MATRIZ-IDENTIDAD](https://github.com/vterreno/ejercicios-curso-python/blob/main/Ejercicios/Ejercicio%20%239%20-%20Volumen%201%20-%20151%20-%20Es%20matriz%20identidad/Volumen%201%20-%20151%20-%20Es%20matriz%20identidad.pdf) | Correcciones: [SOLUCIÓN](https://github.com/vterreno/ejercicios-curso-python/tree/main/Ejercicios/Ejercicio%20%239%20-%20Volumen%201%20-%20151%20-%20Es%20matriz%20identidad/Resoluci%C3%B3n) [[ALUMNOS]](https://github.com/vterreno/ejercicios-curso-python/tree/main/Ejercicios/Ejercicio%20%239%20-%20Volumen%201%20-%20151%20-%20Es%20matriz%20identidad) 33 | * #10 - 28/09/23 | [SIGUIENTE-MATRÍCULA](https://github.com/vterreno/ejercicios-curso-python/blob/main/Ejercicios/Ejercicio%20%2310%20-%20Volumen%201%20-%20154%20-%20Cu%C3%A1l%20es%20la%20siguiente%20matr%C3%ADcula/Volumen%201%20-%20154%20-%20Cu%C3%A1l%20es%20la%20siguiente%20matr%C3%ADcula.pdf) | Correcciones: [SOLUCIÓN](https://github.com/vterreno/ejercicios-curso-python/tree/main/Ejercicios/Ejercicio%20%2310%20-%20Volumen%201%20-%20154%20-%20Cu%C3%A1l%20es%20la%20siguiente%20matr%C3%ADcula/Resoluci%C3%B3n) [[ALUMNOS]](https://github.com/vterreno/ejercicios-curso-python/tree/main/Ejercicios/Ejercicio%20%2310%20-%20Volumen%201%20-%20154%20-%20Cu%C3%A1l%20es%20la%20siguiente%20matr%C3%ADcula) 34 | * #11 - 28/09/23 | [TABLEROS-AJEDREZ](https://github.com/vterreno/ejercicios-curso-python/blob/main/Ejercicios/Ejercicio%20%2311%20-%20Volumen%201%20-%20162%20-%20Tableros%20de%20Ajedrez/Volumen%201%20-%20162%20-%20Tableros%20de%20Ajedrez.pdf) | Correcciones: [SOLUCIÓN](https://github.com/vterreno/ejercicios-curso-python/tree/main/Ejercicios/Ejercicio%20%2311%20-%20Volumen%201%20-%20162%20-%20Tableros%20de%20Ajedrez/Resoluci%C3%B3n) [[ALUMNOS]](https://github.com/vterreno/ejercicios-curso-python/tree/main/Ejercicios/Ejercicio%20%2311%20-%20Volumen%201%20-%20162%20-%20Tableros%20de%20Ajedrez) 35 | * #12 - 28/09/23 | [SUMALE-UNO](https://github.com/vterreno/ejercicios-curso-python/blob/main/Ejercicios/Ejercicio%20%2312%20-%20Volumen%201%20-%20163%20-%20S%C3%BAmale%201/Volumen%201%20-%20163%20-%20S%C3%BAmale%201.pdf) | Correcciones: [SOLUCIÓN](https://github.com/vterreno/ejercicios-curso-python/tree/main/Ejercicios/Ejercicio%20%2312%20-%20Volumen%201%20-%20163%20-%20S%C3%BAmale%201/Resoluci%C3%B3n) [[ALUMNOS]](https://github.com/vterreno/ejercicios-curso-python/tree/main/Ejercicios/Ejercicio%20%2312%20-%20Volumen%201%20-%20163%20-%20S%C3%BAmale%201) 36 | * #13 - 28/09/23 | [✨✨✨PINTANDO-FRACTALES✨✨✨](https://github.com/vterreno/ejercicios-curso-python/blob/main/Ejercicios/Ejercicio%20%2313%20-%20Volumen%201%20-%20167%20-%20Pintando%20Fractales/Volumen%201%20-%20167%20-%20Pintando%20Fractales.pdf) | Correcciones: [SOLUCIÓN](https://github.com/vterreno/ejercicios-curso-python/tree/main/Ejercicios/Ejercicio%20%2313%20-%20Volumen%201%20-%20167%20-%20Pintando%20Fractales/Resoluci%C3%B3n) [[ALUMNOS]](https://github.com/vterreno/ejercicios-curso-python/tree/main/Ejercicios/Ejercicio%20%2313%20-%20Volumen%201%20-%20167%20-%20Pintando%20Fractales) 37 | * #14 - 28/09/23 | [CAMPO-DE-MINAS](https://github.com/vterreno/ejercicios-curso-python/blob/main/Ejercicios/Ejercicio%20%2314%20-%20Volumen%201%20-%20176%20-%20Campo%20de%20Minas/Volumen%201%20-%20176%20-%20Campo%20de%20Minas.pdf) | Correcciones: [SOLUCIÓN](https://github.com/vterreno/ejercicios-curso-python/tree/main/Ejercicios/Ejercicio%20%2314%20-%20Volumen%201%20-%20176%20-%20Campo%20de%20Minas/Resoluci%C3%B3n) [[ALUMNOS]](https://github.com/vterreno/ejercicios-curso-python/tree/main/Ejercicios/Ejercicio%20%2314%20-%20Volumen%201%20-%20176%20-%20Campo%20de%20Minas) 38 | * #15 - 28/09/23 | [MENSAJE-INTERCEPTADO](https://github.com/vterreno/ejercicios-curso-python/blob/main/Ejercicios/Ejercicio%20%2315%20-%20Volumen%201%20-%20197%20-%20Mensaje%20interceptado/Volumen%201%20-%20197%20-%20Mensaje%20interceptado.pdf) | Correcciones: [SOLUCIÓN](https://github.com/vterreno/ejercicios-curso-python/tree/main/Ejercicios/Ejercicio%20%2315%20-%20Volumen%201%20-%20197%20-%20Mensaje%20interceptado/Resoluci%C3%B3n) [[ALUMNOS]](https://github.com/vterreno/ejercicios-curso-python/tree/main/Ejercicios/Ejercicio%20%2315%20-%20Volumen%201%20-%20197%20-%20Mensaje%20interceptado) 39 | * #16 - 28/09/23 | [DURMIENDO-EN-ALBERGUES](https://github.com/vterreno/ejercicios-curso-python/blob/main/Ejercicios/Ejercicio%20%2316%20-%20Volumen%204%20-%20400%20-%20Durmiendo%20en%20albergues/Volumen%204%20-%20400%20-%20Durmiendo%20en%20albergues.pdf) | Correcciones: [SOLUCIÓN](https://github.com/vterreno/ejercicios-curso-python/tree/main/Ejercicios/Ejercicio%20%2316%20-%20Volumen%204%20-%20400%20-%20Durmiendo%20en%20albergues/Resoluci%C3%B3n) [[ALUMNOS]](https://github.com/vterreno/ejercicios-curso-python/tree/main/Ejercicios/Ejercicio%20%2316%20-%20Volumen%204%20-%20400%20-%20Durmiendo%20en%20albergues) 40 | 41 | 42 | 43 | ## ¿Cómo puedo participar? 44 | 45 | **Haz un FORK del proyecto y trabaja con Git para ir sincronizando las actualizaciones.** 46 | 1. En el proyecto tienes un directorio para cada ejercicio. Dentro de cada directorio encontrarás un archivo llamado **enunciado.pdf** con el enunciado de cada reto. 47 | 48 | 2. Si quieres compartir tu propia solución de un ejercicio con el resto de los alumnos, crea un archivo de código con tu nombre y extensión (.py), y realiza una [**PULL REQUEST**](https://docs.github.com/es/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request) contra el repositorio. 49 | 3. El archivo de código debe situarse dentro del directorio del ejercicio correspondiente. Por ejemplo, si has resuelto el ejercico #0 y tu nombre es Juan Perez, tu corrección deberá estar en **"Ejercicios/Ejercicio #0/juanPerez.py"**. El título de la Pull Request también debe seguir este formato: **"Ejercicio #[número] - Nombre del Alumno"**. En el ejemplo anterior sería **"Ejercico #0 - Juan Perez"**. Se rechazarán las Pull Request que no sigan este formato o contengan archivos adicionales. 50 | 4. Podes proponer Pull Request con propuestas o correcciones sobre ejercicios del resto de la comunidad si estos poseen errores. De esta manera colaboraremos para crear un repositorio cada vez más valioso. 51 | 5. Si se te solicita un cambio/corrección en una Pull Request, y al cabo de 2 semanas no se muestra nueva actividad, se cerrará esa petición para mantener el repositorio limpio. Por supuesto, puedes volver a enviar la Pull Request cuando quieras. 52 | 53 | ## Tareas por hacer 54 | - [ ] Crear documentación en PDF para realizar pull request 55 | 56 | ## Equipo "Taller de acompañamiento de algoritmos" 📚 57 | 58 | * **@brunolucarelli5** 59 | * **@vterreno** 60 | * **@ignamosconi** 61 | 62 | Curso dictado en la **Universidad Tecnológica Nacional - Facultad Regional Villa María**. \ 63 | Organizado por: **Departamento de Ingeniería en Sistemas de Información - Secretaría de Asuntos Estudiantiles**. 64 | 65 | --------------------------------------------------------------------------------