├── ene-jun-2023 ├── Chio │ └── example.txt └── practicas │ ├── practica8 │ ├── grafo.png │ └── README.md │ ├── practica1 │ └── README.md │ ├── practica2 │ └── README.md │ ├── practica4 │ └── README.md │ ├── practica3 │ └── README.md │ ├── practica7 │ └── README.md │ ├── practica5 │ └── README.md │ ├── practica6 │ └── README.md │ └── extra │ └── README.md ├── README.md ├── ago-dic-2023 ├── chio │ └── practica1 │ │ └── main.py └── practicas │ ├── practica1 │ └── README.md │ ├── practica5 │ └── README.md │ ├── practica4 │ └── README.md │ ├── practica3 │ └── README.md │ └── practica2 │ └── README.md ├── ago-dic-2022 └── practicas │ ├── practica8 │ ├── grafo.png │ └── README.md │ ├── practica1 │ └── README.md │ ├── practica4 │ └── README.md │ ├── practica5 │ └── README.md │ ├── practica3 │ └── README.md │ ├── practica2 │ └── README.md │ ├── practica9 │ └── README.md │ ├── practica7 │ └── README.md │ └── practica6 │ └── README.md ├── ene-jun-2019 ├── practicas │ ├── practica_7 │ │ ├── grafo.png │ │ └── README.md │ ├── practica_8 │ │ ├── grafo.png │ │ └── README.md │ ├── practica_9 │ │ ├── grafo.png │ │ └── README.md │ ├── practica_1 │ │ └── README.md │ ├── practica_4 │ │ └── README.md │ ├── parcial_1 │ │ └── README.md │ ├── practica_5 │ │ └── README.md │ ├── practica_3 │ │ └── README.md │ ├── practica_2 │ │ └── README.md │ ├── practica_10 │ │ └── README.md │ └── extra │ │ └── README.md ├── Vulpes │ └── HelloClass.py ├── Mario Manzano │ └── Practicas │ │ ├── Practica_2.java │ │ ├── Practica_1.java │ │ ├── Practica_3.java │ │ └── Practica_4.java ├── Cristian_Edgardo │ ├── Practica1 │ │ └── Practica1.java │ └── Practica2 │ │ └── HAMBURGESAS.java ├── Juan Pablo Sarmirento Cervera │ └── Practicas │ │ ├── practica2.java │ │ └── practica1.java ├── Esly Morin Hinojosa │ ├── practica_1 │ │ ├── README.md │ │ └── tarea1.java │ ├── practica_2 │ │ └── tarea2.java │ └── practica_3 │ │ └── tarea3bublesort.java ├── Juan Arnoldo Chavez Munoz │ ├── practica_1 │ │ └── Practica1.java │ └── practica_2 │ │ └── Practica_2.java └── Juan Daniel Salazar Coronado │ ├── practica 1 │ └── practica1.java │ └── practica 2 │ └── F250119.java ├── ene-jun-2020 ├── practicas │ ├── practica9 │ │ ├── grafo.png │ │ └── README.md │ ├── practica1 │ │ └── README.md │ ├── practica2 │ │ └── README.md │ ├── practica7 │ │ └── README.md │ ├── parcial_1 │ │ └── README.md │ ├── practica3 │ │ └── README.md │ ├── practica6 │ │ └── README.md │ ├── practica4 │ │ └── README.md │ └── practica5 │ │ └── README.md └── material │ └── programacion_dinamica │ └── fibonacci.py ├── ago-dic-2018 ├── slides │ ├── basic │ │ ├── insertion_sort.png │ │ ├── insertion.go │ │ └── basic.slide │ ├── intro │ │ ├── intro.go │ │ └── intro1.go │ ├── asymptotic │ │ └── sumto.go │ └── divide-conquer │ │ ├── merge.go │ │ └── divide.slide ├── panchito torres perez │ └── practica_1 │ │ ├── ejemplo.class │ │ └── ejemplo.java ├── David Sena Martinez │ ├── Practica-5 │ │ └── alfabeticamente.java │ ├── Practica-1 │ │ └── Algoritmos.java │ ├── practica-6 │ │ └── BusquedaString.java │ ├── Practica-3 │ │ └── Dinos.java │ └── practica-2 │ │ └── Pokemon.java ├── Guadalupe Alejandro Pérez Camacho │ ├── practica_1 │ │ ├── Alumno.class │ │ ├── JavaApplication5.class │ │ ├── Alumno.java │ │ └── JavaApplication5.java │ ├── practica_4 │ │ └── Libros.java │ ├── practica_3 │ │ ├── Dinos.java │ │ └── ListaDinos.java │ ├── parcial_2 │ │ └── Parcial2P1.java │ ├── practica_2 │ │ └── Pokimon.java │ └── practica_6 │ │ └── BusquedaBinaria.java ├── José Horacio Góngora Treviño │ ├── Practica_1 │ │ ├── Test_Persona.java │ │ └── Persona.java │ ├── Practica_3 │ │ └── Dinosaurios.java │ ├── Practica_4 │ │ ├── MergeSortLibro.java │ │ ├── TestLibro.java │ │ └── Libro.java │ ├── Parcial_1 │ │ ├── MergeSortPelicula.java │ │ ├── TestPelicula.java │ │ └── Pelicula.java │ ├── Practica_6 │ │ ├── PalabrasBS.java │ │ └── BinarySearch.java │ ├── Practica_5 │ │ └── Alfabeto.java │ ├── Practica_8 │ │ └── Bob.java │ └── Practica_2 │ │ └── Pokemon.java ├── practicas │ ├── practica_1 │ │ ├── README.md │ │ └── Algoritmos.java │ ├── practica_5 │ │ └── README.md │ ├── practica_3 │ │ └── README.md │ ├── parcial_1 │ │ └── README.md │ ├── practica_6 │ │ └── README.md │ ├── practica_4 │ │ └── README.md │ ├── practica_2 │ │ └── README.md │ ├── practica_7 │ │ └── README.md │ └── practica_8 │ │ └── README.md └── Pérez Sánchez José Jahir │ ├── Practica 4 │ ├── Libro.java │ └── prueba.java │ ├── Practica 1 │ └── nombresAlgoritmos.java │ ├── Practica 5 │ └── Alfabeticamente.java │ ├── Practica 2 │ └── Pokemon.java │ ├── Pratica 6 │ └── Binario.java │ └── Practica 3 │ └── Dinosaurios.java ├── ago-dic-2021 ├── Juan Antonio Cruz Perez │ ├── practica 2 │ │ ├── Element.java │ │ ├── PracticaDos.java │ │ └── LinkedList.java │ ├── practica 1 │ │ └── Practica1.java │ ├── alogritmosCorregidos │ │ ├── Regalo.java │ │ ├── Materia.java │ │ ├── Pelis.java │ │ └── panchitoYsusRegalosCorre.java │ ├── extra │ │ ├── Cartas.java │ │ └── binaryStr1.java │ ├── parcial 1 │ │ └── SelectionSortDinosaurios.java │ └── practica 4 │ │ └── practiquca4.java └── practicas │ ├── practica1 │ └── README.md │ ├── practica2 │ └── README.md │ ├── practica4 │ └── README.md │ ├── practica7 │ └── README.md │ ├── practica5 │ └── README.md │ ├── practica3 │ └── README.md │ └── practica6 │ └── README.md ├── ene-jun-2021 ├── material │ └── algoritmos │ │ ├── pase.py │ │ ├── grafo.txt │ │ ├── burbuja.py │ │ ├── ejemplo.java │ │ ├── recur.py │ │ ├── insertion.java │ │ ├── isertion21.java │ │ ├── search.java │ │ ├── selection.cpp │ │ ├── bfs.py │ │ ├── mergesort.py │ │ └── suma.java └── practicas │ ├── practica2 │ └── README.md │ ├── practica1 │ └── README.md │ ├── practica5 │ └── README.md │ ├── practica3 │ └── README.md │ ├── practica6 │ └── README.md │ ├── parcial1 │ └── README.md │ ├── practica4 │ └── README.md │ ├── practica7 │ └── README.md │ └── practica8 │ └── README.md ├── ago-dic-2019 ├── Erick O. Escarcega Rmz │ └── PracticAss │ │ └── Practica1.py ├── Jonathan Aguilar │ └── practica1.py ├── Brandon Emmanuel │ └── t1p1numerosenteros.py └── practicas │ ├── practica1 │ └── README.md │ ├── practica4 │ └── README.md │ ├── practica3 │ └── README.md │ ├── practica6 │ └── README.md │ ├── parcial_1 │ └── README.md │ ├── practica5 │ └── README.md │ ├── practica2 │ └── README.md │ ├── practica7 │ └── README.md │ └── extra │ └── README.md ├── ago-dic-2024 └── practicas │ ├── practica_1 │ └── README.md │ ├── practica_4 │ └── README.md │ ├── practica_6 │ └── README.md │ ├── practica_5 │ └── README.md │ ├── practica_3 │ └── README.md │ └── practica_2 │ └── README.md ├── ago-dic-2020 └── practicas │ ├── practica1 │ └── README.md │ ├── practica4 │ └── README.md │ ├── practica5 │ └── README.md │ ├── parcial_1 │ └── README.md │ ├── parcial_1.5 │ └── README.md │ ├── practica3 │ └── README.md │ ├── practica2 │ └── README.md │ └── practica6 │ └── README.md ├── ene-jun-2022 └── practicas │ ├── practica1 │ └── README.md │ ├── practica3 │ └── README.md │ ├── practica7 │ └── README.md │ ├── practica8 │ └── README.md │ ├── practica9 │ └── README.md │ ├── practica4 │ └── README.md │ ├── practica2 │ └── README.md │ ├── practica5 │ └── README.md │ └── practica6 │ └── README.md └── ene-jun-2024 ├── practicas ├── practica1 │ └── README.md ├── practica6 │ └── README.md ├── parcial_1 │ └── README.md ├── practica3 │ └── README.md ├── practica2 │ └── README.md ├── practica4 │ └── README.md └── practica5 │ └── README.md └── Santiago Chio └── practica1 └── counting.java /ene-jun-2023/Chio/example.txt: -------------------------------------------------------------------------------- 1 | holi 2 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Algoritmos de ordenamiento y búsqueda -------------------------------------------------------------------------------- /ago-dic-2023/chio/practica1/main.py: -------------------------------------------------------------------------------- 1 | print(sum(map(int,input().split()))) -------------------------------------------------------------------------------- /ago-dic-2022/practicas/practica8/grafo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/schiob/AlgoritmosSistemas/HEAD/ago-dic-2022/practicas/practica8/grafo.png -------------------------------------------------------------------------------- /ene-jun-2019/practicas/practica_7/grafo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/schiob/AlgoritmosSistemas/HEAD/ene-jun-2019/practicas/practica_7/grafo.png -------------------------------------------------------------------------------- /ene-jun-2019/practicas/practica_8/grafo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/schiob/AlgoritmosSistemas/HEAD/ene-jun-2019/practicas/practica_8/grafo.png -------------------------------------------------------------------------------- /ene-jun-2019/practicas/practica_9/grafo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/schiob/AlgoritmosSistemas/HEAD/ene-jun-2019/practicas/practica_9/grafo.png -------------------------------------------------------------------------------- /ene-jun-2020/practicas/practica9/grafo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/schiob/AlgoritmosSistemas/HEAD/ene-jun-2020/practicas/practica9/grafo.png -------------------------------------------------------------------------------- /ene-jun-2023/practicas/practica8/grafo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/schiob/AlgoritmosSistemas/HEAD/ene-jun-2023/practicas/practica8/grafo.png -------------------------------------------------------------------------------- /ago-dic-2018/slides/basic/insertion_sort.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/schiob/AlgoritmosSistemas/HEAD/ago-dic-2018/slides/basic/insertion_sort.png -------------------------------------------------------------------------------- /ene-jun-2019/Vulpes/HelloClass.py: -------------------------------------------------------------------------------- 1 | nums = input("Ingresa dos números: \n") 2 | a,b = nums.split(" ") 3 | num1 = int(a) 4 | num2 = int(b) 5 | print(num1+num2) 6 | -------------------------------------------------------------------------------- /ene-jun-2019/Mario Manzano/Practicas/Practica_2.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/schiob/AlgoritmosSistemas/HEAD/ene-jun-2019/Mario Manzano/Practicas/Practica_2.java -------------------------------------------------------------------------------- /ene-jun-2019/Cristian_Edgardo/Practica1/Practica1.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/schiob/AlgoritmosSistemas/HEAD/ene-jun-2019/Cristian_Edgardo/Practica1/Practica1.java -------------------------------------------------------------------------------- /ene-jun-2019/Cristian_Edgardo/Practica2/HAMBURGESAS.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/schiob/AlgoritmosSistemas/HEAD/ene-jun-2019/Cristian_Edgardo/Practica2/HAMBURGESAS.java -------------------------------------------------------------------------------- /ago-dic-2021/Juan Antonio Cruz Perez/practica 2/Element.java: -------------------------------------------------------------------------------- 1 | 2 | 3 | package practicas; 4 | 5 | public class Element { 6 | public int datum; 7 | public Element next; 8 | } 9 | -------------------------------------------------------------------------------- /ago-dic-2018/panchito torres perez/practica_1/ejemplo.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/schiob/AlgoritmosSistemas/HEAD/ago-dic-2018/panchito torres perez/practica_1/ejemplo.class -------------------------------------------------------------------------------- /ene-jun-2021/material/algoritmos/pase.py: -------------------------------------------------------------------------------- 1 | def foo(arr_copy): 2 | arr_copy = ["otra cosa", 3,4,5,357,24,57,2] 3 | 4 | arr = [1,3,4,245,2,2,3] 5 | print(arr) 6 | foo(arr) 7 | print(arr) -------------------------------------------------------------------------------- /ago-dic-2018/David Sena Martinez/Practica-5/alfabeticamente.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/schiob/AlgoritmosSistemas/HEAD/ago-dic-2018/David Sena Martinez/Practica-5/alfabeticamente.java -------------------------------------------------------------------------------- /ene-jun-2019/Juan Pablo Sarmirento Cervera/Practicas/practica2.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/schiob/AlgoritmosSistemas/HEAD/ene-jun-2019/Juan Pablo Sarmirento Cervera/Practicas/practica2.java -------------------------------------------------------------------------------- /ago-dic-2018/Guadalupe Alejandro Pérez Camacho/practica_1/Alumno.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/schiob/AlgoritmosSistemas/HEAD/ago-dic-2018/Guadalupe Alejandro Pérez Camacho/practica_1/Alumno.class -------------------------------------------------------------------------------- /ago-dic-2018/José Horacio Góngora Treviño/Practica_1/Test_Persona.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/schiob/AlgoritmosSistemas/HEAD/ago-dic-2018/José Horacio Góngora Treviño/Practica_1/Test_Persona.java -------------------------------------------------------------------------------- /ago-dic-2018/José Horacio Góngora Treviño/Practica_3/Dinosaurios.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/schiob/AlgoritmosSistemas/HEAD/ago-dic-2018/José Horacio Góngora Treviño/Practica_3/Dinosaurios.java -------------------------------------------------------------------------------- /ago-dic-2018/panchito torres perez/practica_1/ejemplo.java: -------------------------------------------------------------------------------- 1 | 2 | public class ejemplo{ 3 | 4 | public static void main(String []args){ 5 | System.out.println("hola clase"); 6 | } 7 | } -------------------------------------------------------------------------------- /ene-jun-2021/material/algoritmos/grafo.txt: -------------------------------------------------------------------------------- 1 | 13 16 2 | 0 1 3 | 1 2 4 | 1 5 5 | 2 3 6 | 2 6 7 | 3 7 8 | 7 12 9 | 12 11 10 | 11 6 11 | 11 10 12 | 10 5 13 | 10 9 14 | 9 8 15 | 8 4 16 | 4 0 17 | 5 6 -------------------------------------------------------------------------------- /ago-dic-2018/José Horacio Góngora Treviño/Practica_4/MergeSortLibro.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/schiob/AlgoritmosSistemas/HEAD/ago-dic-2018/José Horacio Góngora Treviño/Practica_4/MergeSortLibro.java -------------------------------------------------------------------------------- /ago-dic-2018/José Horacio Góngora Treviño/Parcial_1/MergeSortPelicula.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/schiob/AlgoritmosSistemas/HEAD/ago-dic-2018/José Horacio Góngora Treviño/Parcial_1/MergeSortPelicula.java -------------------------------------------------------------------------------- /ago-dic-2018/Guadalupe Alejandro Pérez Camacho/practica_1/JavaApplication5.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/schiob/AlgoritmosSistemas/HEAD/ago-dic-2018/Guadalupe Alejandro Pérez Camacho/practica_1/JavaApplication5.class -------------------------------------------------------------------------------- /ago-dic-2018/practicas/practica_1/README.md: -------------------------------------------------------------------------------- 1 | # Tarea 1 2 | 3 | Sube en tu carpeta tu archivito .java que tiene el ejercicio de los nombres 4 | 5 | ### ATENCIÓN 6 | Creen su carpeta como la del estudiante fantasma panchito -------------------------------------------------------------------------------- /ago-dic-2019/Erick O. Escarcega Rmz/PracticAss/Practica1.py: -------------------------------------------------------------------------------- 1 | a = [] 2 | n = int(input("Cuantos numeritos quieres primo Tom?!?\n")) 3 | print("Dime los numeritos Tom") 4 | for i in range(n): 5 | k = int(input()) 6 | if k%2 == 0: 7 | a.append(str(k)) 8 | print(' '.join(a[::-1])) -------------------------------------------------------------------------------- /ago-dic-2021/practicas/practica1/README.md: -------------------------------------------------------------------------------- 1 | # Practica1 2 | Escribe un programa que tome como entrada 2 enteros separados por un espacio e imprima la suma de estos 2 enteros. 3 | 4 | ## Ejemplo 5 | 6 | ### Entrada 7 | ``` 8 | 3 5 9 | ``` 10 | 11 | ### Salida 12 | ``` 13 | 8 14 | ``` -------------------------------------------------------------------------------- /ago-dic-2022/practicas/practica1/README.md: -------------------------------------------------------------------------------- 1 | # Practica1 2 | Escribe un programa que tome como entrada 2 enteros separados por un espacio e imprima la suma de estos 2 enteros. 3 | 4 | ## Ejemplo 5 | 6 | ### Entrada 7 | ``` 8 | 3 5 9 | ``` 10 | 11 | ### Salida 12 | ``` 13 | 8 14 | ``` -------------------------------------------------------------------------------- /ene-jun-2023/practicas/practica1/README.md: -------------------------------------------------------------------------------- 1 | # Practica1 2 | Escribe un programa que tome como entrada 2 enteros separados por un espacio e imprima la suma de estos 2 enteros. 3 | 4 | ## Ejemplo 5 | 6 | ### Entrada 7 | ``` 8 | 3 5 9 | ``` 10 | 11 | ### Salida 12 | ``` 13 | 8 14 | ``` -------------------------------------------------------------------------------- /ago-dic-2019/Jonathan Aguilar/practica1.py: -------------------------------------------------------------------------------- 1 | lista = [] 2 | lista2=[] 3 | i=0 4 | while(i<20): 5 | num=(int(input("ingrese un numero: "))) 6 | lista.append(num) 7 | i+=1 8 | if(num%2==0): 9 | lista2.append(num) 10 | print(lista) 11 | print(lista2) 12 | lista2.reverse() 13 | print(lista2) 14 | -------------------------------------------------------------------------------- /ene-jun-2019/Mario Manzano/Practicas/Practica_1.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | 3 | public class Practica_1 { 4 | public static void main(String[]args) { 5 | Scanner s = new Scanner(System.in); 6 | int a = s.nextInt(); 7 | int b = s.nextInt(); 8 | int x = a + b; 9 | System.out.println(x); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /ago-dic-2018/slides/intro/intro.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | // start function OMIT 6 | func Sum(x int, y int) int { 7 | return x + y 8 | } 9 | 10 | // end function OMIT 11 | 12 | // start main OMIT 13 | func main() { 14 | numero := Sum(4, 7) 15 | fmt.Println(numero) 16 | } 17 | 18 | // end main OMIT 19 | -------------------------------------------------------------------------------- /ene-jun-2021/material/algoritmos/burbuja.py: -------------------------------------------------------------------------------- 1 | arr = [4,3,6,7,6754,33,46,8,5,3,4,6,3,2,7,8,879,12] 2 | 3 | print(arr) 4 | 5 | i = len(arr) 6 | while i > 1: 7 | for j in range(0, i-1): 8 | if arr[j] < arr[j+1]: 9 | temp = arr[j] 10 | arr[j] = arr[j+1] 11 | arr[j+1] = temp 12 | 13 | i -= 1 14 | 15 | print(arr) -------------------------------------------------------------------------------- /ene-jun-2019/Juan Pablo Sarmirento Cervera/Practicas/practica1.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | public class Practica1 3 | { 4 | public static void main(String args[]) 5 | { 6 | Scanner s = new Scanner(System.in); 7 | int num = s.nextInt(); 8 | int num2 = s.nextInt(); 9 | System.out.println(" "+(num+num2)); 10 | } 11 | } -------------------------------------------------------------------------------- /ago-dic-2024/practicas/practica_1/README.md: -------------------------------------------------------------------------------- 1 | # Práctica 1 - hello class 2 | 3 | Crea tu carpeta con un programa que tome 2 enteros separados por un espacio e imaprima el resultado de la suma de esos 2 enteros. 4 | 5 | Ejemplo: 6 | 7 | Entrada: 8 | 9 | `4 6` 10 | 11 | Salida: 12 | 13 | `10` 14 | 15 | Todo esto por entrada y salida estandar (system.out, system.in) 16 | -------------------------------------------------------------------------------- /ago-dic-2023/practicas/practica1/README.md: -------------------------------------------------------------------------------- 1 | # Práctica 1 - hello class 2 | Crea tu carpeta con un programa que tome 2 enteros separados por un espacio e imaprima el resultado de la suma de esos 2 enteros. 3 | 4 | Ejemplo: 5 | 6 | Entrada: 7 | 8 | ` 9 | 4 6 10 | ` 11 | 12 | Salida: 13 | 14 | ` 15 | 10 16 | ` 17 | 18 | Todo esto por entrada y salida estandar (system.out, system.in) -------------------------------------------------------------------------------- /ene-jun-2019/practicas/practica_1/README.md: -------------------------------------------------------------------------------- 1 | # Práctica 1 - hello class 2 | Crea tu carpeta con un programa que tome 2 enteros separados por un espacio e imaprima el resultado de la suma de esos 2 enteros. 3 | 4 | Ejemplo: 5 | 6 | Entrada: 7 | 8 | ` 9 | 4 6 10 | ` 11 | 12 | Salida: 13 | 14 | ` 15 | 10 16 | ` 17 | 18 | Todo esto por entrada y salida estandar (system.out, system.in) -------------------------------------------------------------------------------- /ene-jun-2019/Esly Morin Hinojosa/practica_1/README.md: -------------------------------------------------------------------------------- 1 | # Práctica 1 - hello class 2 | Crea tu carpeta con un programa que tome 2 enteros separados por un espacio e imaprima el resultado de la suma de esos 2 enteros. 3 | 4 | Ejemplo: 5 | 6 | Entrada: 7 | 8 | ` 9 | 4 6 10 | ` 11 | 12 | Salida: 13 | 14 | ` 15 | 10 16 | ` 17 | 18 | Todo esto por entrada y salida estandar (system.out, system.in) -------------------------------------------------------------------------------- /ene-jun-2019/Esly Morin Hinojosa/practica_1/tarea1.java: -------------------------------------------------------------------------------- 1 | package proyectoesli; 2 | import java.util.*; 3 | 4 | public class tarea1 5 | { 6 | public static void main (String []args) 7 | { 8 | Scanner sc=new Scanner(System.in); 9 | int a,b; 10 | System.out.println("dame numero"); 11 | a=sc.nextInt(); 12 | b=sc.nextInt(); 13 | a+=b; 14 | System.out.println("suma="+a); 15 | } 16 | 17 | } 18 | -------------------------------------------------------------------------------- /ene-jun-2021/material/algoritmos/ejemplo.java: -------------------------------------------------------------------------------- 1 | import jdk.javadoc.internal.doclets.formats.html.SystemPropertiesWriter; 2 | 3 | public class ejemplo{ 4 | public static void main(String [] args) { 5 | Scanner s = new Scanner(System.in); 6 | 7 | int n = s.nextInt(); 8 | for(int i = 0; i < 10; i++){ // O(1) 9 | System.out.println("holi"); 10 | } 11 | } -------------------------------------------------------------------------------- /ago-dic-2019/Brandon Emmanuel/t1p1numerosenteros.py: -------------------------------------------------------------------------------- 1 | array1= [] 2 | array2= [] 3 | 4 | print("infresa numeros ") 5 | for i in range (1,6): 6 | n=int(input()) 7 | array1.append(n) 8 | if (n %2==0): 9 | array2.append(n) 10 | 11 | 12 | print("numeros",array1) 13 | print("numeros pares ",array2) 14 | array2.reverse() 15 | print("orden inverso", array2) 16 | 17 | #apend va agregando al ultimo 18 | #reverse, imprime al reves 19 | 20 | 21 | 22 | 23 | 24 | 25 | -------------------------------------------------------------------------------- /ago-dic-2020/practicas/practica1/README.md: -------------------------------------------------------------------------------- 1 | # Practica 1 2 | Suma 2 enteros e imprime el resultado 3 | 4 | ## Entrada 5 | La entrada se tomará por STDIN en una sola linea donde hay 2 enteros **x** y **y**, donde **-100 <= x, y <= 100**. Estos enteros están separados por un espacio. 6 | 7 | ## Salida 8 | Imprime en STDOUT en una sola linea la suma de los 2 enteros. 9 | 10 | ## Ejemplo 11 | 12 | ### Entrada 13 | ``` 14 | -5 84 15 | ``` 16 | ### Salida 17 | ``` 18 | 79 19 | ``` 20 | -------------------------------------------------------------------------------- /ene-jun-2020/practicas/practica1/README.md: -------------------------------------------------------------------------------- 1 | # Practica 1 2 | Suma 2 enteros e imprime el resultado 3 | 4 | ## Entrada 5 | La entrada se tomará por STDIN en una sola linea donde hay 2 enteros **x** y **y**, donde **-100 <= x, y <= 100**. Estos enteros están separados por un espacio. 6 | 7 | ## Salida 8 | Imprime en STDOUT en una sola linea la suma de los 2 enteros. 9 | 10 | ## Ejemplo 11 | 12 | ### Entrada 13 | ``` 14 | -5 84 15 | ``` 16 | ### Salida 17 | ``` 18 | 79 19 | ``` 20 | -------------------------------------------------------------------------------- /ene-jun-2022/practicas/practica1/README.md: -------------------------------------------------------------------------------- 1 | # Practica 1 2 | Suma 2 enteros e imprime el resultado 3 | 4 | ## Entrada 5 | La entrada se tomará por STDIN en una sola linea donde hay 2 enteros **x** y **y**, donde **-100 <= x, y <= 100**. Estos enteros están separados por un espacio. 6 | 7 | ## Salida 8 | Imprime en STDOUT en una sola linea la suma de los 2 enteros. 9 | 10 | ## Ejemplo 11 | 12 | ### Entrada 13 | ``` 14 | -5 84 15 | ``` 16 | ### Salida 17 | ``` 18 | 79 19 | ``` 20 | -------------------------------------------------------------------------------- /ene-jun-2024/practicas/practica1/README.md: -------------------------------------------------------------------------------- 1 | # Practica 1 2 | Suma 2 enteros e imprime el resultado 3 | 4 | ## Entrada 5 | La entrada se tomará por STDIN en una sola linea donde hay 2 enteros **x** y **y**, donde **-100 <= x, y <= 100**. Estos enteros están separados por un espacio. 6 | 7 | ## Salida 8 | Imprime en STDOUT en una sola linea la suma de los 2 enteros. 9 | 10 | ## Ejemplo 11 | 12 | ### Entrada 13 | ``` 14 | -5 84 15 | ``` 16 | ### Salida 17 | ``` 18 | 79 19 | ``` 20 | -------------------------------------------------------------------------------- /ago-dic-2019/practicas/practica1/README.md: -------------------------------------------------------------------------------- 1 | # Practica 1 2 | Tom, mi primo al que le encantan los numeritos, tiene una lista de 20 enteros. Pero tiene un problema donde después de las 9 p.m. le asustan los números impares. 3 | 4 | Ayúdale removiendo esos números e imprime la lista que tiene en orden inverso. 5 | 6 | ## Ejemplo 7 | 8 | ### Entrada 9 | ``` 10 | 3 43 2 5 4 6 5 4 334 45 23 123 323 45 34 23 43 5 46 78 11 | ``` 12 | 13 | ### Salida 14 | ``` 15 | 78 46 34 334 4 6 4 2 16 | ``` -------------------------------------------------------------------------------- /ago-dic-2021/Juan Antonio Cruz Perez/practica 1/Practica1.java: -------------------------------------------------------------------------------- 1 | 2 | package practicas; 3 | 4 | import java.util.Scanner; 5 | 6 | 7 | public class Practica1 { 8 | public static void main(String[] args) { 9 | Scanner n1 = new Scanner(System.in); 10 | int nu, nd,res; 11 | nu = n1.nextInt(); 12 | nd = n1.nextInt(); 13 | 14 | res = nu + nd; 15 | 16 | 17 | System.out.println(res); 18 | 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /ago-dic-2021/practicas/practica2/README.md: -------------------------------------------------------------------------------- 1 | # Practica 2 2 | Tom, mi primo al que le encantan los numeritos, tiene una lista de 20 enteros. Pero tiene un problema donde después de las 9 p.m. le asustan los números impares. 3 | 4 | Ayúdale removiendo esos números e imprime la lista que tiene en orden inverso. 5 | 6 | ## Ejemplo 7 | 8 | ### Entrada 9 | ``` 10 | 3 43 2 5 4 6 5 4 334 45 23 123 323 45 34 23 43 5 46 78 11 | ``` 12 | 13 | ### Salida 14 | ``` 15 | 78 46 34 334 4 6 4 2 16 | ``` -------------------------------------------------------------------------------- /ene-jun-2020/practicas/practica2/README.md: -------------------------------------------------------------------------------- 1 | # Practica 2 2 | Tom, mi primo al que le encantan los numeritos, tiene una lista de 20 enteros. Pero tiene un problema donde después de las 9 p.m. le asustan los números impares. 3 | 4 | Ayúdale removiendo esos números e imprime la lista ordenada de mayor a menor. 5 | 6 | ## Ejemplo 7 | 8 | ### Entrada 9 | ``` 10 | 3 43 2 5 4 6 5 4 334 45 23 123 323 45 34 23 43 5 46 78 11 | ``` 12 | 13 | ### Salida 14 | ``` 15 | 334 78 46 34 6 4 4 2 16 | ``` -------------------------------------------------------------------------------- /ene-jun-2021/practicas/practica2/README.md: -------------------------------------------------------------------------------- 1 | # Practica 2 2 | Tom, mi primo al que le encantan los numeritos, tiene una lista de 20 enteros. Pero tiene un problema donde después de las 9 p.m. le asustan los números impares. 3 | 4 | Ayúdale removiendo esos números e imprime la lista ordenada de mayor a menor. 5 | 6 | ## Ejemplo 7 | 8 | ### Entrada 9 | ``` 10 | 3 43 2 5 4 6 5 4 334 45 23 123 323 45 34 23 43 5 46 78 11 | ``` 12 | 13 | ### Salida 14 | ``` 15 | 334 78 46 34 6 4 4 2 16 | ``` -------------------------------------------------------------------------------- /ene-jun-2023/practicas/practica2/README.md: -------------------------------------------------------------------------------- 1 | # Practica 2 2 | Tom, mi primo al que le encantan los numeritos, tiene una lista de 20 enteros. Pero tiene un problema donde después de las 9 p.m. le asustan los números impares. 3 | 4 | Ayúdale removiendo esos números e imprime la lista ordenada de mayor a menor. 5 | 6 | ## Ejemplo 7 | 8 | ### Entrada 9 | ``` 10 | 3 43 2 5 4 6 5 4 334 45 23 123 323 45 34 23 43 5 46 78 11 | ``` 12 | 13 | ### Salida 14 | ``` 15 | 334 78 46 34 6 4 4 2 16 | ``` -------------------------------------------------------------------------------- /ago-dic-2018/José Horacio Góngora Treviño/Practica_6/PalabrasBS.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | public class PalabrasBS 3 | { 4 | public static void main(String[]args) 5 | { 6 | Scanner sc= new Scanner(System.in); 7 | String dato; 8 | String a[]= {"ahola","amundo","cabc","dqwerty","ea72","fjamon","gpanadero"}; 9 | BinarySearch x=new BinarySearch(); 10 | 11 | System.out.println("Palabra a buscar:"); 12 | dato=sc.nextLine(); 13 | 14 | System.out.println(x.BinarySearch(a, 0, a.length-1, dato)); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /ago-dic-2018/José Horacio Góngora Treviño/Practica_4/TestLibro.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | public class TestLibro { 3 | 4 | public static void main(String[] args) 5 | { 6 | Scanner sc = new Scanner(System.in); 7 | System.out.print("Numero de Libros: "); 8 | int n=sc.nextInt(); 9 | 10 | MergeSortLibro x = new MergeSortLibro(n); 11 | x.ingresar(sc); 12 | System.out.println(x); 13 | 14 | System.out.println("Ordenado por Numero de paginas"); 15 | x.MSL(0, x.l.length); 16 | System.out.println(x); 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /ago-dic-2018/José Horacio Góngora Treviño/Parcial_1/TestPelicula.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | public class TestPelicula 3 | { 4 | public static void main(String[] args) 5 | { 6 | Scanner sc = new Scanner(System.in); 7 | System.out.print("Numero de Peliculas: "); 8 | int n=sc.nextInt(); 9 | 10 | MergeSortPelicula x = new MergeSortPelicula(n); 11 | x.ingresar(sc); 12 | System.out.println(x); 13 | 14 | System.out.println("Ordenado por Numero de Horas y Minutos"); 15 | x.MSP(0, x.p.length); 16 | System.out.println(x); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /ago-dic-2018/David Sena Martinez/Practica-1/Algoritmos.java: -------------------------------------------------------------------------------- 1 | 2 | package algoritmos; 3 | 4 | public class Algoritmos { 5 | 6 | public static void main(String[] args) { 7 | String nombres [] = {"Pepe","Armando","Armando","Pepe","Maria","Pepe"}; 8 | 9 | for (int i = 0; i = 0 && arr[i] > actual { 12 | arr[i+1] = arr[i] 13 | i-- 14 | } 15 | arr[i+1] = actual 16 | } 17 | return arr 18 | } 19 | 20 | // end insertionSort OMIT 21 | 22 | // start main OMIT 23 | func main() { 24 | arr := []int{4, 2, 5, 6, 2, 4, 5, 9, 1, 3} 25 | fmt.Println(arr) 26 | sortedArr := insertionSort(arr) 27 | fmt.Println(sortedArr) 28 | } 29 | 30 | // end main OMIT 31 | -------------------------------------------------------------------------------- /ene-jun-2019/Juan Arnoldo Chavez Munoz/practica_1/Practica1.java: -------------------------------------------------------------------------------- 1 | 2 | package algoritmosorden; 3 | 4 | 5 | import java.util.Scanner; 6 | public class Practica1 { 7 | public static void main(String[] args) { 8 | int v1=0, v2=0; 9 | Scanner s= new Scanner (System.in); 10 | 11 | System.out.println("Ingresa un numero:"); 12 | v1= s.nextInt(); 13 | System.out.println("Ingresa un numero:"); 14 | v2=s.nextInt(); 15 | System.out.print("Los numeros ingresados fueron: "+v1+" "+v2); 16 | System.out.println(""); 17 | int sumat=v1+v2; 18 | System.out.println("La suma total es: "+sumat); 19 | 20 | 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /ago-dic-2018/Guadalupe Alejandro Pérez Camacho/practica_4/Libros.java: -------------------------------------------------------------------------------- 1 | package javaapplication5; 2 | 3 | public class Libros { 4 | private String titulo; 5 | private int pages; 6 | public Libros(String s, int x){ 7 | titulo=s; 8 | pages=x; 9 | } 10 | 11 | public String getTitulo() { 12 | return titulo; 13 | } 14 | 15 | public void setTitulo(String titulo) { 16 | this.titulo = titulo; 17 | } 18 | 19 | public int getPages() { 20 | return pages; 21 | } 22 | 23 | public void setPages(int pages) { 24 | this.pages = pages; 25 | } 26 | 27 | } 28 | -------------------------------------------------------------------------------- /ago-dic-2018/Pérez Sánchez José Jahir/Practica 4/Libro.java: -------------------------------------------------------------------------------- 1 | 2 | package algoritmos; 3 | 4 | class Libro { 5 | String name; 6 | int pages; 7 | 8 | public Libro(String name, int pages) { 9 | this.name = name; 10 | this.pages = pages; 11 | } 12 | 13 | public String getName() { 14 | return name; 15 | } 16 | 17 | public void setName(String name) { 18 | this.name = name; 19 | } 20 | 21 | public int getPages() { 22 | return pages; 23 | } 24 | 25 | public void setPages(int pages) { 26 | this.pages = pages; 27 | } 28 | 29 | 30 | 31 | } 32 | -------------------------------------------------------------------------------- /ago-dic-2018/José Horacio Góngora Treviño/Practica_4/Libro.java: -------------------------------------------------------------------------------- 1 | 2 | public class Libro 3 | { 4 | private String nombre; 5 | private int pag; 6 | 7 | public Libro(String nombre, int pag) 8 | { 9 | super(); 10 | this.nombre=nombre; 11 | this.pag=pag; 12 | } 13 | 14 | public String getNombre() 15 | { 16 | return nombre; 17 | } 18 | 19 | public void setNombre(String nombre) 20 | { 21 | this.nombre=nombre; 22 | } 23 | 24 | public int getPag() 25 | { 26 | return pag; 27 | } 28 | 29 | public void setPag(int pag) 30 | { 31 | this.pag=pag; 32 | } 33 | 34 | public String toString() 35 | { 36 | return nombre + "," + pag; 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /ene-jun-2021/material/algoritmos/recur.py: -------------------------------------------------------------------------------- 1 | def factorial(n): 2 | if n == 1: 3 | return 1 4 | return n * factorial(n-1) 5 | 6 | def factorial_iter(n): 7 | total = 1 8 | for x in range(1, n+1): 9 | total *= x 10 | 11 | return total 12 | 13 | def fib(n): 14 | if n == 0 or n == 1: 15 | return 1 16 | return fib(n-1) + fib(n-2) 17 | 18 | def fib_iter(n): 19 | anterior = 1 20 | nuevo = 1 21 | for _ in range(n-1): 22 | temp = nuevo 23 | nuevo = anterior + nuevo 24 | anterior = temp 25 | 26 | return nuevo 27 | 28 | 29 | if __name__ == "__main__": 30 | print(fib(5)) 31 | print(fib_iter(5)) -------------------------------------------------------------------------------- /ene-jun-2021/practicas/practica1/README.md: -------------------------------------------------------------------------------- 1 | # Práctica 1 2 | Escribe un programita que tome 2 números como entrada y regrese la suma de esos números como salida. 3 | 4 | ## Especificaciones de entrada 5 | La entrada se dará por STDIN (la terminal) (java -> scanner(System.in)) 6 | 7 | La entrada consiste de una sola linea con dos números *x*, *y* separados por un espacio. Donde `0 <= x,y <= 100`. 8 | 9 | ## Especificaciones de salida 10 | La salida se dará por STDOUT (la terminal) (java -> System.out.Print) 11 | 12 | Imprimir una sola linea con el número resultado de la suma de *x* y *y*. 13 | 14 | ## Ejemplo 15 | 16 | ### Input 17 | ` 18 | 5 9 19 | ` 20 | ### Output 21 | ` 22 | 14 23 | ` 24 | -------------------------------------------------------------------------------- /ago-dic-2018/Guadalupe Alejandro Pérez Camacho/practica_3/Dinos.java: -------------------------------------------------------------------------------- 1 | /* 2 | * To change this license header, choose License Headers in Project Properties. 3 | * To change this template file, choose Tools | Templates 4 | * and open the template in the editor. 5 | */ 6 | package javaapplication5; 7 | /** 8 | * 9 | * @author Acer 10 | */ 11 | public class Dinos { 12 | String nombre; 13 | public Dinos(String x){ 14 | nombre=x; 15 | } 16 | public String getNombre(){ 17 | return nombre; 18 | } 19 | public int getTamañoNombre(){ 20 | return nombre.length(); 21 | } 22 | public void setNombre(String n){ 23 | nombre=n; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /ene-jun-2021/material/algoritmos/insertion.java: -------------------------------------------------------------------------------- 1 | public class insertion{ 2 | public static void main(String [] args) { 3 | char []arr = {'f', 'h', 'g', 'q', 'a', 'n', 'p'}; 4 | 5 | 6 | // Insertion sort 7 | for(int i = 1 ; i < arr.length ; i++){ 8 | char actual = arr[i]; 9 | int j = i-1; 10 | for(; j >= 0 ; j--){ 11 | if(arr[j] > actual){ 12 | break; 13 | } 14 | arr[j+1] = arr[j]; 15 | } 16 | 17 | arr[j+1] = actual; 18 | } 19 | 20 | // Print 21 | for(int val:arr){ 22 | System.out.printf("%c ", val); 23 | } 24 | } 25 | } -------------------------------------------------------------------------------- /ene-jun-2021/material/algoritmos/isertion21.java: -------------------------------------------------------------------------------- 1 | public class isertion21{ 2 | public static void main(String[] args){ 3 | int []arr = {3,5,6,4,2}; 4 | 5 | // Inicio el insertion sort 6 | for(int i = 1; i < arr.length; i++){ 7 | int actual = arr[i]; 8 | 9 | int j = i-1; 10 | for(; j >= 0; j--){ 11 | if(actual < arr[j]){ 12 | arr[j+1] = arr[j]; 13 | } 14 | else{ 15 | break; 16 | } 17 | } 18 | arr[j+1] = actual; 19 | } 20 | 21 | for(int elem: arr){ 22 | System.out.printf("%d ", elem); 23 | } 24 | } 25 | } -------------------------------------------------------------------------------- /ago-dic-2018/José Horacio Góngora Treviño/Practica_6/BinarySearch.java: -------------------------------------------------------------------------------- 1 | 2 | public class BinarySearch 3 | { 4 | public int BinarySearch(String a[], int inicio, int ultimo, String dato) 5 | { 6 | int mid = (inicio+ultimo)/2; 7 | 8 | if(inicio==ultimo) 9 | { 10 | if(a[inicio].compareTo(dato)==0) 11 | { 12 | return inicio; 13 | } 14 | return -1; 15 | } 16 | 17 | if(a[mid]==dato) 18 | { 19 | return mid; 20 | } 21 | 22 | if(a[mid].compareTo(dato)>0 ) 23 | { 24 | if(a[mid-1].compareTo(dato)==0) 25 | return mid-1; 26 | return BinarySearch(a,inicio,mid-1,dato); 27 | } 28 | 29 | if(a[mid].compareTo(dato)<0) 30 | { 31 | return BinarySearch(a,mid+1,ultimo,dato); 32 | } 33 | return mid; 34 | 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /ago-dic-2021/Juan Antonio Cruz Perez/alogritmosCorregidos/Regalo.java: -------------------------------------------------------------------------------- 1 | 2 | public class Regalo { 3 | 4 | public String Regalo; 5 | public int numero; 6 | 7 | public Regalo() { 8 | 9 | } 10 | 11 | public Regalo(String nombre, int numero) { 12 | this.Regalo = nombre; 13 | this.numero = numero; 14 | } 15 | 16 | public String getRegalo() { 17 | return Regalo; 18 | } 19 | 20 | public void setRegalo(String Regalo) { 21 | this.Regalo = Regalo; 22 | } 23 | 24 | public int getNumero() { 25 | return numero; 26 | } 27 | 28 | public void setNumero(int numero) { 29 | this.numero = numero; 30 | } 31 | 32 | public String toString() { 33 | return "\n" + Regalo; 34 | } 35 | 36 | } 37 | -------------------------------------------------------------------------------- /ago-dic-2021/Juan Antonio Cruz Perez/alogritmosCorregidos/Materia.java: -------------------------------------------------------------------------------- 1 | 2 | public class Materia { 3 | 4 | public String nombre; 5 | public int numero; 6 | 7 | public Materia() { 8 | 9 | } 10 | 11 | public Materia(String nombre, int numero) { 12 | this.nombre = nombre; 13 | this.numero = numero; 14 | } 15 | 16 | public String getNombre() { 17 | return nombre; 18 | } 19 | 20 | public void setNombre(String nombre) { 21 | this.nombre = nombre; 22 | } 23 | 24 | public int getNumero() { 25 | return numero; 26 | } 27 | 28 | public void setNumero(int numero) { 29 | this.numero = numero; 30 | } 31 | 32 | public String toString() { 33 | return "\n" + nombre; 34 | } 35 | 36 | } 37 | -------------------------------------------------------------------------------- /ago-dic-2018/Pérez Sánchez José Jahir/Practica 1/nombresAlgoritmos.java: -------------------------------------------------------------------------------- 1 | package algoritmos; 2 | public class nombresAlgoritmos { 3 | public static void main(String[] args) { 4 | String[]nombres={"Juan","Pepe","Luis","Juan"}; 5 | int maximo=0; 6 | String Elmayor=""; 7 | for (int i = 0; i < nombres.length; i++) { 8 | int q=0; 9 | for (int j = 0; j < nombres.length; j++) { 10 | if(nombres[i]==nombres[j]){ 11 | q++; 12 | } 13 | if(q>maximo){ 14 | Elmayor=nombres[i]; 15 | } 16 | maximo=q; 17 | 18 | } 19 | } 20 | System.out.println(Elmayor +"\t"+ maximo); 21 | } 22 | 23 | } 24 | -------------------------------------------------------------------------------- /ago-dic-2018/Guadalupe Alejandro Pérez Camacho/parcial_2/Parcial2P1.java: -------------------------------------------------------------------------------- 1 | package javaapplication5; 2 | 3 | import java.util.*; 4 | 5 | public class Parcial2P1 { 6 | public static void main(String[]args){ 7 | boolean b=false; 8 | Scanner s = new Scanner(System.in); 9 | String [] input = s.nextLine().split(" "); 10 | int a=Integer.parseInt(input[0]),i=0; 11 | String libro = input[1]; 12 | String [] lista = s.nextLine().split(" "); 13 | while (!libro.equalsIgnoreCase(lista[i])) { 14 | i++; 15 | if (libro.equalsIgnoreCase(lista[i])) { 16 | b=true; 17 | } 18 | } 19 | if (b==false) { 20 | System.out.println("-1"); 21 | } 22 | else System.out.println(i+1); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /ago-dic-2018/José Horacio Góngora Treviño/Practica_1/Persona.java: -------------------------------------------------------------------------------- 1 | 2 | public class Persona 3 | { 4 | private String Nombre=""; 5 | private int contador; 6 | Persona(String n) 7 | { 8 | this.Nombre=n; 9 | this.contador=1; 10 | } 11 | 12 | public String toString() 13 | { 14 | return "Alumno{" + "Nombre=" + Nombre+'}'; 15 | } 16 | 17 | public String getNombre() 18 | { 19 | return Nombre; 20 | } 21 | 22 | public void setNombre(String Nombre) 23 | { 24 | this.Nombre = Nombre; 25 | } 26 | 27 | public int getContador() 28 | { 29 | return contador; 30 | } 31 | 32 | public void setContador(int contador) 33 | { 34 | this.contador = contador; 35 | } 36 | 37 | } 38 | -------------------------------------------------------------------------------- /ene-jun-2019/Esly Morin Hinojosa/practica_2/tarea2.java: -------------------------------------------------------------------------------- 1 | package proyectoesli; 2 | import java.util.*; 3 | public class tarea2 4 | { 5 | public static void main(String[]args) 6 | { 7 | Scanner sc=new Scanner(System.in); 8 | int x[],i,j,n,temp=0; 9 | System.out.println("cuantas hamburguesas??"); 10 | n=sc.nextInt(); 11 | x=new int [n]; 12 | System.out.println("dame puntuacion de cada hamburguesa"); 13 | for(i=0;i-1 && x[j] ady[]= new ArrayList[MAX]; 6 | 7 | public static void main(String[]args) 8 | { 9 | int estanque, rios, origen, destino; 10 | Scanner sc= new Scanner(System.in); 11 | 12 | System.out.println("Numero de Estanques"); 13 | estanque= sc.nextInt(); 14 | System.out.println("Numero de rios"); 15 | rios= sc.nextInt(); 16 | 17 | System.out.println("Origen y destino de cada estanque atraves de los rios"); 18 | 19 | for(int i=0;i<=rios;i++) 20 | { 21 | origen= sc.nextInt(); 22 | destino= sc.nextInt(); 23 | 24 | ady[origen].add(destino); 25 | ady[destino].add(origen); 26 | 27 | rios--; 28 | } 29 | System.out.println(ady); 30 | } 31 | 32 | } 33 | -------------------------------------------------------------------------------- /ene-jun-2021/material/algoritmos/search.java: -------------------------------------------------------------------------------- 1 | 2 | public class search { 3 | public static void main(String args[]) { 4 | int []arr = {1, 2, 3, 4, 5, 6, 7, 19, 45, 56, 72, 73, 74, 453}; 5 | 6 | int buscar = 57; 7 | 8 | System.out.println(binarySearch(arr, 0, arr.length-1, buscar)); 9 | } 10 | 11 | public static int binarySearch(int[] arr, int inicio, int fin, int buscando){ 12 | int middle = (inicio+fin)/2; 13 | if (arr[middle] == buscando){ 14 | return middle; 15 | } 16 | if (inicio == fin){ 17 | return -1; 18 | } 19 | 20 | if (arr[middle] < buscando){ 21 | return binarySearch(arr, middle+1, fin, buscando); 22 | } 23 | else{ 24 | return binarySearch(arr, inicio, middle-1, buscando); 25 | } 26 | } 27 | 28 | } -------------------------------------------------------------------------------- /ago-dic-2018/José Horacio Góngora Treviño/Parcial_1/Pelicula.java: -------------------------------------------------------------------------------- 1 | 2 | public class Pelicula 3 | { 4 | private String nombre; 5 | private int hrs; 6 | private int min; 7 | 8 | public Pelicula(String nombre, int hrs, int min) 9 | { 10 | super(); 11 | this.nombre=nombre; 12 | this.hrs=hrs; 13 | this.min=min; 14 | } 15 | 16 | public String getNombre() 17 | { 18 | return nombre; 19 | } 20 | 21 | public void setNombre(String nombre) 22 | { 23 | this.nombre=nombre; 24 | } 25 | 26 | public int getHrs() 27 | { 28 | return hrs; 29 | } 30 | 31 | public void setHrs(int hrs) 32 | { 33 | this.hrs=hrs; 34 | } 35 | 36 | public int getMin() 37 | { 38 | return min; 39 | } 40 | 41 | public void setMin(int min) 42 | { 43 | this.min=min; 44 | } 45 | 46 | public String toString() 47 | { 48 | return nombre + "," + hrs+":"+min; 49 | } 50 | } 51 | -------------------------------------------------------------------------------- /ago-dic-2021/practicas/practica4/README.md: -------------------------------------------------------------------------------- 1 | # Práctica 4 2 | 3 | A Ricardo le encantan las palabras, grades, pequeñas, con vocales y consonantes. Tiene una lista don sus palabras favoritas y quiere que le ayudes a ordenarlas por orden alfabético. 4 | 5 | ### Input 6 | 7 | La entrada será recibida por **STDIN** 8 | 9 | Consiste en 2 lineas, la primera tiene un entero **n** representado el número de palabras en la lista de Ricardo. 10 | 11 | En la segunda linea está la lista con **n** palabras separados por espacio. 12 | 13 | ### Output 14 | 15 | Imprime a salida estandar **STDOUT** la lista ordenada de forma alfanumérica. 16 | 17 | ### Ejemplos 18 | 19 | #### Entrada 20 | ``` 21 | 7 22 | text2a text2 text2a12 a a12 text2a2 b2 23 | ``` 24 | #### Salida 25 | 26 | ``` 27 | a a12 b2 text2 text2a text2a2 text2a12 28 | ``` 29 | 30 | ## NOTA 31 | Ordénalo con una implementación de merge sort -------------------------------------------------------------------------------- /ago-dic-2024/practicas/practica_4/README.md: -------------------------------------------------------------------------------- 1 | # Práctica 4 2 | 3 | A Ricardo le encantan las palabras, grades, pequeñas, con vocales y consonantes. Tiene una lista don sus palabras favoritas y quiere que le ayudes a ordenarlas por orden alfabético. 4 | 5 | ### Input 6 | 7 | La entrada será recibida por **STDIN** 8 | 9 | Consiste en 2 lineas, la primera tiene un entero **n** representado el número de palabras en la lista de Ricardo. 10 | 11 | En la segunda linea está la lista con **n** palabras separados por espacio. 12 | 13 | ### Output 14 | 15 | Imprime a salida estandar **STDOUT** la lista ordenada de forma alfanumérica. 16 | 17 | ### Ejemplos 18 | 19 | #### Entrada 20 | ``` 21 | 7 22 | text2a text2 text2a12 a a12 text2a2 b2 23 | ``` 24 | #### Salida 25 | 26 | ``` 27 | a a12 b2 text2 text2a text2a2 text2a12 28 | ``` 29 | 30 | ## NOTA 31 | Ordénalo con una implementación de merge sort -------------------------------------------------------------------------------- /ago-dic-2021/Juan Antonio Cruz Perez/practica 2/PracticaDos.java: -------------------------------------------------------------------------------- 1 | package practicas; 2 | 3 | import java.util.Scanner; 4 | 5 | public class PracticaDos { 6 | 7 | public static void main(String[] args) { 8 | LinkedList lista = new LinkedList(); 9 | Scanner sw = new Scanner (System.in); 10 | String s =""; 11 | //ingresar numeros a la lista separados por espacio 12 | s = sw.nextLine(); 13 | String num[] = s.split("\\s+"); 14 | //total de probleas 15 | for (int i = 0; i < num.length; i++) { 16 | lista.preppend(Integer.parseInt(num[i])); 17 | } 18 | 19 | System.out.println("--------------------- "); 20 | 21 | lista.imprimir(); 22 | 23 | System.out.println("--------------------"); 24 | lista.quitaInPares(); 25 | lista.imprimir(); 26 | 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /ago-dic-2018/practicas/practica_1/Algoritmos.java: -------------------------------------------------------------------------------- 1 | 2 | package algoritmos; 3 | 4 | 5 | public class Algoritmos { 6 | 7 | public static void main(String[] args) { 8 | 9 | String[]nombres={"Juan","Juan","Pepe","Ana"}; 10 | int n=0; 11 | String Nombrepopular=""; 12 | 13 | for (int i = 0; i n){ 22 | Nombrepopular=nombres[i]; 23 | } 24 | n=contador; 25 | } 26 | } 27 | System.out.println("El Nombre mas Popular es:"+Nombrepopular + "\t"+ "Numero de Veces:"+ n ); 28 | 29 | 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /ago-dic-2019/practicas/practica4/README.md: -------------------------------------------------------------------------------- 1 | # Practica 4 - Un poco de recursividad pal cuerpo 2 | Juanito tiene una pequeña obsesión con las palabras. Su ultimo fanatismo es sobre los palíndromos. Ya sabes las palabras que de derecha a izquierda dicen lo mismo como *radar*, *sanas*, *acurruca*, *reconocer*, etc. 3 | 4 | El detalle es que Juanito quiere un programa con el que pueda checar si una palabra es palíndromo o no. 5 | 6 | Ayudalo a hacer ese programa utilizando una función recursiva. 7 | 8 | ### Input 9 | Consiste en una linea que tiene una palabra. 10 | 11 | ### Output 12 | 13 | Imprime a salida estandar **si es** si la palabra es palíndromo, o **no es** en caso contrario. 14 | 15 | ### Ejemplos 16 | 17 | #### Entrada 18 | ``` 19 | reconocer 20 | ``` 21 | #### Salida 22 | 23 | ``` 24 | si es 25 | ``` 26 | 27 | #### Entrada 28 | ``` 29 | pokemon 30 | ``` 31 | #### Salida 32 | 33 | ``` 34 | no es 35 | ``` -------------------------------------------------------------------------------- /ago-dic-2020/practicas/practica4/README.md: -------------------------------------------------------------------------------- 1 | # Practica 4 - Un poco de recursividad pal cuerpo 2 | Juanito tiene una pequeña obsesión con las palabras. Su ultimo fanatismo es sobre los palíndromos. Ya sabes las palabras que de derecha a izquierda dicen lo mismo como *radar*, *sanas*, *acurruca*, *reconocer*, etc. 3 | 4 | El detalle es que Juanito quiere un programa con el que pueda checar si una palabra es palíndromo o no. 5 | 6 | Ayudalo a hacer ese programa utilizando una función recursiva. 7 | 8 | ### Input 9 | Consiste en una linea que tiene una palabra. 10 | 11 | ### Output 12 | 13 | Imprime a salida estandar **si es** si la palabra es palíndromo, o **no es** en caso contrario. 14 | 15 | ### Ejemplos 16 | 17 | #### Entrada 18 | ``` 19 | reconocer 20 | ``` 21 | #### Salida 22 | 23 | ``` 24 | si es 25 | ``` 26 | 27 | #### Entrada 28 | ``` 29 | pokemon 30 | ``` 31 | #### Salida 32 | 33 | ``` 34 | no es 35 | ``` -------------------------------------------------------------------------------- /ago-dic-2020/practicas/practica5/README.md: -------------------------------------------------------------------------------- 1 | # Práctica 5 - Mas ordenamiento pero diferente 2 | 3 | A Ricardo le encantan las palabras, grades, pequeñas, con vocales y consonantes. Tiene una lista don sus palabras favoritas y quiere que le ayudes a ordenarlas por orden alfabético. 4 | 5 | ### Input 6 | 7 | La entrada será recibida por **STDIN** 8 | 9 | Consiste en 2 lineas, la primera tiene un entero **n** representado el número de palabras en la lista de Ricardo. 10 | 11 | En la segunda linea está la lista con **n** palabras separados por espacio. 12 | 13 | ### Output 14 | 15 | Imprime a salida estandar **STDOUT** la lista ordenada de forma alfanumérica. 16 | 17 | ### Ejemplos 18 | 19 | #### Entrada 20 | ``` 21 | 7 22 | text2a text2 text2a12 a a12 text2a2 b2 23 | ``` 24 | #### Salida 25 | 26 | ``` 27 | a a12 b2 text2 text2a text2a2 text2a12 28 | ``` 29 | 30 | ## NOTA 31 | Ordénalo con una implementación de quick sort -------------------------------------------------------------------------------- /ago-dic-2022/practicas/practica4/README.md: -------------------------------------------------------------------------------- 1 | # Práctica 4 - Mas ordenamiento pero diferente 2 | 3 | A Ricardo le encantan las palabras, grades, pequeñas, con vocales y consonantes. Tiene una lista don sus palabras favoritas y quiere que le ayudes a ordenarlas por orden alfabético. 4 | 5 | ### Input 6 | 7 | La entrada será recibida por **STDIN** 8 | 9 | Consiste en 2 lineas, la primera tiene un entero **n** representado el número de palabras en la lista de Ricardo. 10 | 11 | En la segunda linea está la lista con **n** palabras separados por espacio. 12 | 13 | ### Output 14 | 15 | Imprime a salida estandar **STDOUT** la lista ordenada de forma alfanumérica. 16 | 17 | ### Ejemplos 18 | 19 | #### Entrada 20 | ``` 21 | 7 22 | text2a text2 text2a12 a a12 text2a2 b2 23 | ``` 24 | #### Salida 25 | 26 | ``` 27 | a a12 b2 text2 text2a text2a2 text2a12 28 | ``` 29 | 30 | ## NOTA 31 | Ordénalo con una implementación de merge sort -------------------------------------------------------------------------------- /ago-dic-2023/practicas/practica5/README.md: -------------------------------------------------------------------------------- 1 | # Practica 5 - Ordenando más 2 | A Manuel le gustan mucho los dinosaurios y los nombres tan extraños que pueden tener, algunos de esos nombres pueden ser muy largos, como *Pachycephalosaurus*, Manuel tiene una lista con nombres de dinosaurios y quiere ordenarla de los nombres más cortos a los más largos. 3 | 4 | Ayuda a Manuel haciendo un programa que haga eso. 5 | 6 | ### Input 7 | Consiste en una linea que tiene nombres de dinosaurios separados por un espacio. 8 | 9 | ### Output 10 | 11 | Imprime a salida estandar la lista de los dinosaurios ordenados de más corto a más largo. 12 | 13 | ### Ejemplos 14 | 15 | #### Entrada 16 | ``` 17 | Parasaurolophus Oviraptor Minmi Troodon Wannanosaurus 18 | ``` 19 | #### Salida 20 | 21 | ``` 22 | Minmi Troodon Oviraptor Wannanosaurus Parasaurolophus 23 | ``` 24 | 25 | ### Notas 26 | 27 | Resuelve el problema haciendo una implementación de merge sort. -------------------------------------------------------------------------------- /ago-dic-2023/practicas/practica4/README.md: -------------------------------------------------------------------------------- 1 | # Práctica 4 - Mas ordenamiento pero diferente 2 | 3 | A Ricardo le encantan las palabras, grades, pequeñas, con vocales y consonantes. Tiene una lista don sus palabras favoritas y quiere que le ayudes a ordenarlas por orden alfabético. 4 | 5 | ### Input 6 | 7 | La entrada será recibida por **STDIN** 8 | 9 | Consiste en 2 lineas, la primera tiene un entero **n** representado el número de palabras en la lista de Ricardo. 10 | 11 | En la segunda linea está la lista con **n** palabras separados por espacio. 12 | 13 | ### Output 14 | 15 | Imprime a salida estandar **STDOUT** la lista ordenada de forma alfanumérica. 16 | 17 | ### Ejemplos 18 | 19 | #### Entrada 20 | ``` 21 | 7 22 | text2a text2 text2a12 a a12 text2a2 b2 23 | ``` 24 | #### Salida 25 | 26 | ``` 27 | a a12 b2 text2 text2a text2a2 text2a12 28 | ``` 29 | 30 | ## NOTA 31 | Ordénalo con alguno de los algoritmos que hemos visto en clase -------------------------------------------------------------------------------- /ene-jun-2021/material/algoritmos/selection.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main(){ 6 | int arr[] = {3,5,6,7,453,56,7,3,45,6,72,4,6,73,4,5,74,1}; 7 | 8 | for(int i = 0; i < sizeof(arr)/sizeof(*arr); i++){ 9 | cout << arr[i] << " "; 10 | } 11 | cout << endl; 12 | 13 | // Selection Sort 14 | for(int i = 0; i < sizeof(arr)/sizeof(*arr); i++){ 15 | int min = arr[i]; 16 | int min_idx = i; 17 | 18 | for(int j = i+1; j < sizeof(arr)/sizeof(*arr); j++){ 19 | if(min > arr[j]){ 20 | min = arr[j]; 21 | min_idx = j; 22 | } 23 | } 24 | 25 | int temp = arr[i]; 26 | arr[i] = min; 27 | arr[min_idx] = temp; 28 | } 29 | // END selection sort 30 | 31 | for(int i = 0; i < sizeof(arr)/sizeof(*arr); i++){ 32 | cout << arr[i] << " "; 33 | } 34 | cout << endl; 35 | } -------------------------------------------------------------------------------- /ene-jun-2019/practicas/practica_4/README.md: -------------------------------------------------------------------------------- 1 | # Práctica 3 - Mas ordenamiento pero diferente 2 | 3 | A Ricardo le encantan las palabras, grades, pequeñas, con vocales y consonantes. Tiene una lista don sus palabras favoritas y quiere que le ayudes a ordenarlas por orden alfabético. 4 | 5 | ### Input 6 | 7 | La entrada será recibida por **STDIN** 8 | 9 | Consiste en 2 lineas, la primera tiene un entero **n** representado el número de palabras en la lista de Ricardo. 10 | 11 | En la segunda linea está la lista con **n** palabras separados por espacio. 12 | 13 | ### Output 14 | 15 | Imprime a salida estandar **STDOUT** la lista ordenada de forma alfanumérica. 16 | 17 | ### Ejemplos 18 | 19 | #### Entrada 20 | ``` 21 | 7 22 | text2a text2 text2a12 a a12 text2a2 b2 23 | ``` 24 | #### Salida 25 | 26 | ``` 27 | a a12 b2 text2 text2a text2a2 text2a12 28 | ``` 29 | 30 | ### Notas 31 | 32 | Resuelve el problema haciendo una implementación de merge sort. -------------------------------------------------------------------------------- /ene-jun-2020/material/programacion_dinamica/fibonacci.py: -------------------------------------------------------------------------------- 1 | from datetime import datetime 2 | 3 | tab = [0, 1, 1] 4 | 5 | def fib(x): 6 | if len(tab) > x: 7 | return tab[x] 8 | 9 | tab.append(fib(x-1) + fib(x-2)) 10 | return tab[x] 11 | 12 | def fib1(x): 13 | if x == 1 or x == 2: 14 | return 1 15 | 16 | return fib1(x-1) + fib1(x-2) 17 | 18 | 19 | def fib_iter(x): 20 | anterior1 = 1 21 | anterior2 = 1 22 | for _ in range(2, x): 23 | new = anterior2 + anterior1 24 | anterior1 = anterior2 25 | anterior2 = new 26 | 27 | return anterior2 28 | 29 | tab_iter = [0,] 30 | 31 | def fib_iter(x): 32 | tab_iter.append(1) 33 | tab_iter.append(1) 34 | for i in range(len(tab_iter)-1, x): 35 | new = tab_iter[i-1] + tab_iter[i-2] 36 | tab_iter.append(new) 37 | 38 | return tab_iter[x] 39 | 40 | 41 | if __name__ == "__main__": 42 | print(datetime.now()) 43 | fib_iter(100000) 44 | print(datetime.now()) -------------------------------------------------------------------------------- /ene-jun-2021/practicas/practica5/README.md: -------------------------------------------------------------------------------- 1 | # Práctica 5 - Mas ordenamiento pero diferente 2 | 3 | A Ricardo le encantan las palabras, grades, pequeñas, con vocales y consonantes. Tiene una lista don sus palabras favoritas y quiere que le ayudes a ordenarlas por orden alfabético. 4 | 5 | ### Input 6 | 7 | La entrada será recibida por **STDIN** 8 | 9 | Consiste en 2 lineas, la primera tiene un entero **n** representado el número de palabras en la lista de Ricardo. 10 | 11 | En la segunda linea está la lista con **n** palabras separados por espacio. 12 | 13 | ### Output 14 | 15 | Imprime a salida estandar **STDOUT** la lista ordenada de forma alfanumérica. 16 | 17 | ### Ejemplos 18 | 19 | #### Entrada 20 | ``` 21 | 7 22 | text2a text2 text2a12 a a12 text2a2 b2 23 | ``` 24 | #### Salida 25 | 26 | ``` 27 | a a12 b2 text2 text2a text2a2 text2a12 28 | ``` 29 | 30 | ### Notas 31 | 32 | Resuelve el problema haciendo una implementación de merge sort. -------------------------------------------------------------------------------- /ene-jun-2022/practicas/practica7/README.md: -------------------------------------------------------------------------------- 1 | # Práctica 7 - Mas ordenamiento pero diferente 2 | 3 | A Ricardo le encantan las palabras, grades, pequeñas, con vocales y consonantes. Tiene una lista don sus palabras favoritas y quiere que le ayudes a ordenarlas por orden alfabético. 4 | 5 | ### Input 6 | 7 | La entrada será recibida por **STDIN** 8 | 9 | Consiste en 2 lineas, la primera tiene un entero **n** representado el número de palabras en la lista de Ricardo. 10 | 11 | En la segunda linea está la lista con **n** palabras separados por espacio. 12 | 13 | ### Output 14 | 15 | Imprime a salida estandar **STDOUT** la lista ordenada de forma alfanumérica. 16 | 17 | ### Ejemplos 18 | 19 | #### Entrada 20 | ``` 21 | 7 22 | text2a text2 text2a12 a a12 text2a2 b2 23 | ``` 24 | #### Salida 25 | 26 | ``` 27 | a a12 b2 text2 text2a text2a2 text2a12 28 | ``` 29 | 30 | ### Notas 31 | 32 | Resuelve el problema haciendo una implementación de merge sort. -------------------------------------------------------------------------------- /ene-jun-2019/Juan Daniel Salazar Coronado/practica 1/practica1.java: -------------------------------------------------------------------------------- 1 | /* 2 | * To change this license header, choose License Headers in Project Properties. 3 | * To change this template file, choose Tools | Templates 4 | * and open the template in the editor. 5 | */ 6 | package Algoritmos; 7 | 8 | import java.util.Scanner; 9 | 10 | /** 11 | * 12 | * @author salaz 13 | */ 14 | public class practica1 { 15 | public static void main(String[] args) 16 | { 17 | Scanner s = new Scanner(System.in); 18 | 19 | int n1; 20 | int n2; 21 | int n3; 22 | 23 | System.out.println("Introduzca el primer numero de la suma"); 24 | n1 = s.nextInt(); 25 | 26 | System.out.println("Introduzca el segundo numero de la suma"); 27 | n2 = s.nextInt(); 28 | 29 | n3 = n1 + n2; 30 | 31 | System.out.println("Su numero es: " + n3); 32 | 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /ago-dic-2019/practicas/practica3/README.md: -------------------------------------------------------------------------------- 1 | # Practica 3 - Ordenando más 2 | A Manuel le gustan mucho los dinosaurios y los nombres tan extraños que pueden tener, algunos de esos nombres pueden ser muy largos, como *Pachycephalosaurus*, Manuel tiene una lista con nombres de dinosaurios y quiere ordenarla de los nombres más cortos a los más largos. 3 | 4 | Ayuda a Manuel haciendo un programa que haga eso. 5 | 6 | ### Input 7 | Consiste en una linea que tiene nombres de dinosaurios separados por un espacio. 8 | 9 | ### Output 10 | 11 | Imprime a salida estandar la lista de los dinosaurios ordenados de más corto a más largo. 12 | 13 | ### Ejemplos 14 | 15 | #### Entrada 16 | ``` 17 | Parasaurolophus Oviraptor Minmi Troodon Wannanosaurus 18 | ``` 19 | #### Salida 20 | 21 | ``` 22 | Minmi Troodon Oviraptor Wannanosaurus Parasaurolophus 23 | ``` 24 | 25 | ### Notas 26 | 27 | Resuelve el problema haciendo una implementación de cualquier algoritmo de ordenamiento que hemos visto en clase. -------------------------------------------------------------------------------- /ago-dic-2022/practicas/practica5/README.md: -------------------------------------------------------------------------------- 1 | # Practica 5 - Ordenando más 2 | A Manuel le gustan mucho los dinosaurios y los nombres tan extraños que pueden tener, algunos de esos nombres pueden ser muy largos, como *Pachycephalosaurus*, Manuel tiene una lista con nombres de dinosaurios y quiere ordenarla de los nombres más cortos a los más largos. 3 | 4 | Ayuda a Manuel haciendo un programa que haga eso. 5 | 6 | ### Input 7 | Consiste en una linea que tiene nombres de dinosaurios separados por un espacio. 8 | 9 | ### Output 10 | 11 | Imprime a salida estandar la lista de los dinosaurios ordenados de más corto a más largo. 12 | 13 | ### Ejemplos 14 | 15 | #### Entrada 16 | ``` 17 | Parasaurolophus Oviraptor Minmi Troodon Wannanosaurus 18 | ``` 19 | #### Salida 20 | 21 | ``` 22 | Minmi Troodon Oviraptor Wannanosaurus Parasaurolophus 23 | ``` 24 | 25 | ### Notas 26 | 27 | Resuelve el problema haciendo una implementación de cualquier algoritmo de ordenamiento que hemos visto en clase. -------------------------------------------------------------------------------- /ago-dic-2018/Guadalupe Alejandro Pérez Camacho/practica_1/Alumno.java: -------------------------------------------------------------------------------- 1 | /* 2 | * To change this license header, choose License Headers in Project Properties. 3 | * To change this template file, choose Tools | Templates 4 | * and open the template in the editor. 5 | */ 6 | package javaapplication5; 7 | 8 | /** 9 | * 10 | * @author Acer 11 | */ 12 | public class Alumno { 13 | private String Nombre=""; 14 | private int contador; 15 | Alumno(String n){ 16 | this.Nombre=n; 17 | this.contador=1; 18 | } 19 | 20 | @Override 21 | public String toString() { 22 | return "Alumno{" + "Nombre=" + Nombre+'}'; 23 | } 24 | 25 | public String getNombre() { 26 | return Nombre; 27 | } 28 | 29 | public void setNombre(String Nombre) { 30 | this.Nombre = Nombre; 31 | } 32 | 33 | public int getContador() { 34 | return contador; 35 | } 36 | 37 | public void setContador(int contador) { 38 | this.contador = contador; 39 | } 40 | 41 | } 42 | -------------------------------------------------------------------------------- /ago-dic-2021/Juan Antonio Cruz Perez/extra/Cartas.java: -------------------------------------------------------------------------------- 1 | 2 | public class Cartas { 3 | public int valor,J,Q,K; 4 | public String palo; 5 | public Cartas (int val,String palo){ 6 | this.valor = val; 7 | this.palo = palo; 8 | J=11; 9 | Q=12; 10 | K=13; 11 | 12 | } 13 | 14 | public int getValor() { 15 | return valor; 16 | } 17 | 18 | public void setValor(int valor) { 19 | this.valor = valor; 20 | } 21 | 22 | public int getJ() { 23 | return J; 24 | } 25 | 26 | public void setJ(int J) { 27 | this.J = J; 28 | } 29 | 30 | public int getQ() { 31 | return Q; 32 | } 33 | 34 | public void setQ(int Q) { 35 | this.Q = Q; 36 | } 37 | 38 | public int getK() { 39 | return K; 40 | } 41 | 42 | public void setK(int K) { 43 | this.K = K; 44 | } 45 | 46 | public String getPalo() { 47 | return palo; 48 | } 49 | 50 | public void setPalo(String palo) { 51 | this.palo = palo; 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /ago-dic-2018/slides/asymptotic/sumto.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "time" 6 | ) 7 | 8 | // start f1 OMIT 9 | func sumTo(n int) int { 10 | return n * (n - 1) / 2 11 | } 12 | 13 | // end f1 OMIT 14 | 15 | // start f2 OMIT 16 | func sumTo2(n int) int { 17 | sum := 0 18 | 19 | for i := 0; i < n; i++ { 20 | sum += i 21 | } 22 | 23 | return sum 24 | } 25 | 26 | // end f2 OMIT 27 | 28 | // start f3 OMIT 29 | func sumTo3(n int) int { 30 | sum := 0 31 | 32 | for i := 0; i < n; i++ { 33 | for j := 0; j < i; j++ { 34 | sum++ 35 | } 36 | } 37 | 38 | return sum 39 | } 40 | 41 | // end f3 OMIT 42 | 43 | // start main OMIT 44 | func main() { 45 | n := 1000000 46 | 47 | start := time.Now() 48 | fmt.Print(sumTo(n)) 49 | fmt.Printf(" took %s\n", time.Since(start)) 50 | 51 | start = time.Now() 52 | fmt.Print(sumTo2(n)) 53 | fmt.Printf(" took %s\n", time.Since(start)) 54 | 55 | start = time.Now() 56 | fmt.Print(sumTo3(n)) 57 | fmt.Printf(" took %s\n", time.Since(start)) 58 | } 59 | 60 | // end main OMIT 61 | -------------------------------------------------------------------------------- /ago-dic-2018/practicas/practica_3/README.md: -------------------------------------------------------------------------------- 1 | # Práctica 3 - Ordenando 2 | 3 | A Manuel le gustan mucho los dinosaurios y los nombres tan extraños que pueden tener, algunos de esos nombres pueden ser muy largos, como *Pachycephalosaurus*, Manuel tiene una lista con nombres de dinosaurios y quiere ordenarla de los nombres más cortos a los más largos. 4 | 5 | Ayuda a Manuel haciendo un programa que haga eso. 6 | 7 | ### Input 8 | 9 | La entrada será recibida por **STDIN** 10 | 11 | Consiste en una linea que tiene nombres de dinosaurios separados por un espacio. 12 | 13 | ### Output 14 | 15 | Imprime a salida estandar **STDOUT**, la lista de los dinosaurios ordenados de más corto a más largo. 16 | 17 | ### Ejemplos 18 | 19 | #### Entrada 20 | ``` 21 | Parasaurolophus Oviraptor Minmi Troodon Wannanosaurus 22 | ``` 23 | #### Salida 24 | 25 | ``` 26 | Minmi Troodon Oviraptor Wannanosaurus Parasaurolophus 27 | ``` 28 | 29 | ### Notas 30 | 31 | Resuelve el problema haciendo una implementación de cualquier algoritmo de ordenamiento que hemos visto en clase. -------------------------------------------------------------------------------- /ene-jun-2021/practicas/practica3/README.md: -------------------------------------------------------------------------------- 1 | # Práctica 3 - Ordenando 2 | 3 | A Manuel le gustan mucho los dinosaurios y los nombres tan extraños que pueden tener, algunos de esos nombres pueden ser muy largos, como *Pachycephalosaurus*, Manuel tiene una lista con nombres de dinosaurios y quiere ordenarla de los nombres más cortos a los más largos. 4 | 5 | Ayuda a Manuel haciendo un programa que haga eso. 6 | 7 | ### Input 8 | 9 | La entrada será recibida por **STDIN** 10 | 11 | Consiste en una linea que tiene nombres de dinosaurios separados por un espacio. 12 | 13 | ### Output 14 | 15 | Imprime a salida estandar **STDOUT**, la lista de los dinosaurios ordenados de más corto a más largo. 16 | 17 | ### Ejemplos 18 | 19 | #### Entrada 20 | ``` 21 | Parasaurolophus Oviraptor Minmi Troodon Wannanosaurus 22 | ``` 23 | #### Salida 24 | 25 | ``` 26 | Minmi Troodon Oviraptor Wannanosaurus Parasaurolophus 27 | ``` 28 | 29 | ### Notas 30 | 31 | Resuelve el problema haciendo una implementación de cualquier algoritmo de ordenamiento que hemos visto en clase. -------------------------------------------------------------------------------- /ene-jun-2021/practicas/practica6/README.md: -------------------------------------------------------------------------------- 1 | # Practica 6 - El profe está enfermo 2 | 3 | El profe Chio se enfermó de la garganta y le recetaron un montón de drogas para que se cure. Por la fiebre no quiere andar batallando para encontrar la medicina que ocupa así que ayúdalo haciendo un programa que le ayude a ordenar los medicamentos en orden alfabético. 4 | 5 | ### Input 6 | 7 | La entrada será recibida por **STDIN** 8 | 9 | Consiste en dos lineas, la primera tiene 1 entero, **n** representado el número de medicinas. 10 | 11 | Después hay 1 línea con **n** palabras separadas por espacios, cada palabra es el nombre de una medicina. 12 | 13 | ### Output 14 | 15 | Imprime a salida estandar **STDOUT** una linea con las medicinas ordenas en orden alfabético. 16 | 17 | ### Ejemplos 18 | 19 | #### Entrada 20 | ``` 21 | 5 22 | naproxeno paracetamol rimantadina azitromicina ibuprofeno 23 | ``` 24 | #### Salida 25 | 26 | ``` 27 | azitromicina ibuprofeno naproxeno paracetamol rimantadina 28 | ``` 29 | 30 | ### Notas 31 | 32 | Resuelve el problema haciendo una implementación de quicksort. -------------------------------------------------------------------------------- /ene-jun-2022/practicas/practica8/README.md: -------------------------------------------------------------------------------- 1 | # Practica 8 - El profe está enfermo 2 | 3 | El profe Chio se enfermó de la garganta y le recetaron un montón de drogas para que se cure. Por la fiebre no quiere andar batallando para encontrar la medicina que ocupa así que ayúdalo haciendo un programa que le ayude a ordenar los medicamentos en orden alfabético. 4 | 5 | ### Input 6 | 7 | La entrada será recibida por **STDIN** 8 | 9 | Consiste en dos lineas, la primera tiene 1 entero, **n** representado el número de medicinas. 10 | 11 | Después hay 1 línea con **n** palabras separadas por espacios, cada palabra es el nombre de una medicina. 12 | 13 | ### Output 14 | 15 | Imprime a salida estandar **STDOUT** una linea con las medicinas ordenas en orden alfabético. 16 | 17 | ### Ejemplos 18 | 19 | #### Entrada 20 | ``` 21 | 5 22 | naproxeno paracetamol rimantadina azitromicina ibuprofeno 23 | ``` 24 | #### Salida 25 | 26 | ``` 27 | azitromicina ibuprofeno naproxeno paracetamol rimantadina 28 | ``` 29 | 30 | ### Notas 31 | 32 | Resuelve el problema haciendo una implementación de quicksort. -------------------------------------------------------------------------------- /ene-jun-2019/Esly Morin Hinojosa/practica_3/tarea3bublesort.java: -------------------------------------------------------------------------------- 1 | package proyectoesli; 2 | import java.util.*; 3 | public class tarea3bublesort 4 | { 5 | public static void main(String[]args) 6 | { 7 | Scanner sc=new Scanner(System.in); 8 | int num[]; 9 | String nom[]; 10 | int i,j,n,temp; 11 | String temp2; 12 | System.out.println("cuantos objetos hay en el almacen"); 13 | n=sc.nextInt(); 14 | nom=new String [n]; 15 | num=new int [n]; 16 | System.out.println("que objetos y cuantos hay en el almacen??"); 17 | for(i=0;i50) 11 | { 12 | System.out.println("Cuantos pokemon capuraste (de 1 a 50):"); 13 | n= s.nextInt(); 14 | } 15 | 16 | int a[] = new int[n]; 17 | 18 | for(int i=0;i2000) 21 | { 22 | System.out.println("Cual es su PC (de 1 a 2000:)"); 23 | m= s.nextInt(); 24 | } 25 | 26 | a[i]=m; 27 | m=0; 28 | } 29 | 30 | for (int i = 1; i < a.length; i++) 31 | { 32 | int q=a[i]; 33 | int j=i-1; 34 | 35 | while (j!=-1 && q>a[j]) 36 | { 37 | a[j+1]=a[j]; 38 | j--; 39 | } 40 | a[j+1]=q; 41 | } 42 | 43 | for(int i=0;i 0) { 31 | fin = mitad - 1; 32 | } else { 33 | return mitad; 34 | } 35 | } 36 | return -1; 37 | } 38 | 39 | } 40 | 41 | 42 | -------------------------------------------------------------------------------- /ago-dic-2024/practicas/practica_6/README.md: -------------------------------------------------------------------------------- 1 | ## Ejercicio Práctica 6 2 | 3 | Tom está encerrado en su casa sin muchas cosas que hacer, así que decide retomar su pasatiempo de pintura. El problema es que después de meses sin atender su estudio con cientos de lápices de colores le resulta un poco complicado encontrar el color que quiere. 4 | 5 | Por fortuna cada color tiene un número de identificación por lo que si se ordenan por ese id su colección quedará perfectamente ordenada. 6 | Ayúdalo a ordenar los colores con un programa que facilite el proceso. 7 | 8 | ### Input 9 | 10 | La entrada será recibida por **STDIN** 11 | 12 | Consiste en 2 lineas, la primera tiene un enteros, **n** representado el número de colores. 13 | 14 | La segunda línea tiene **n** enteros **i** separadas por espacios, representando el id del color. 15 | 16 | ### Output 17 | 18 | Imprime a salida estandar **STDOUT** una linea con el orden de los colores. 19 | 20 | ### Ejemplos 21 | 22 | #### Entrada 23 | ``` 24 | 7 25 | 77 133 97 335 487 99 103 26 | ``` 27 | #### Salida 28 | 29 | ``` 30 | 77 97 99 103 133 335 487 31 | ``` 32 | 33 | ### Notas 34 | 35 | Resuelve el problema haciendo una implementación de quick sort. 36 | -------------------------------------------------------------------------------- /ene-jun-2021/practicas/practica4/README.md: -------------------------------------------------------------------------------- 1 | # Práctica 4 2 | 3 | Susana le encanta jugar Minecraft, en donde se pasa horas explorando, obteniendo recursos y construyendo cosas. Después de días jugando Susana ya ha acumulado cientos de objetos en su almacén, y quiere que le ayudes a ordenar sus objetos. 4 | 5 | ### Input 6 | 7 | La entrada será recibida por **STDIN** 8 | 9 | La primera linea contine un entero **n** donde **1 <= n <= 50** y representa el número de objetos diferentes que tiene Susana en su almacén. 10 | 11 | Las siguientes líneas tiene un string **s** que representa el nombre del objeto y un entero **1 <= x <= 100**, la cantidad del objeto en el almacén, separados por un espacio donde. 12 | 13 | 14 | ### Output 15 | 16 | Imprime a salida estandar **STDOUT** 17 | 18 | La salida es una línea con los **n** objetos ordenados de mayor a menor. 19 | 20 | ### Ejemplos 21 | 22 | #### Entrada 23 | ``` 24 | 6 25 | RedStone 40 26 | Dirt 60 27 | Books 32 28 | Wood 12 29 | Stone 55 30 | Sand 43 31 | ``` 32 | #### Salida 33 | 34 | ``` 35 | Dirt Stone Sand RedStone Books Wood 36 | ``` 37 | 38 | ### Notas 39 | 40 | Resuelve el problema haciendo una implementación de selection sort, bubble sort o insertion sort. -------------------------------------------------------------------------------- /ago-dic-2018/slides/intro/intro1.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | // start func 1 OMIT 6 | func MasPopular1(arr []string) string { 7 | bestCount := 0 8 | bestName := "" 9 | 10 | for i := 0; i < len(arr); i++ { 11 | name := arr[i] 12 | count := 0 13 | 14 | for j := 0; i < len(arr); i++ { 15 | if arr[j] == name { 16 | count++ 17 | } 18 | } 19 | if count > bestCount { 20 | bestCount = count 21 | bestName = name 22 | } 23 | } 24 | 25 | return bestName 26 | } 27 | 28 | // end func 1 OMIT 29 | 30 | // start func 2 OMIT 31 | func MasPopular2(arr []string) string { 32 | mapa := make(map[string]int) 33 | 34 | for i := 0; i < len(arr); i++ { 35 | mapa[arr[i]]++ 36 | } 37 | 38 | best := 0 39 | bestName := "" 40 | for k, v := range mapa { 41 | if v > best { 42 | best = v 43 | bestName = k 44 | } 45 | } 46 | 47 | return bestName 48 | } 49 | 50 | //end func 2 OMIT 51 | 52 | // start main OMIT 53 | func main() { 54 | alumnos := []string{"Juan", "Lupe", "Mario", "Juan", "Miguel", "Sofia"} 55 | 56 | popular1 := MasPopular1(alumnos) 57 | popular2 := MasPopular2(alumnos) 58 | 59 | fmt.Println(popular1) 60 | fmt.Println(popular2) 61 | 62 | } 63 | 64 | // end main OMIT 65 | -------------------------------------------------------------------------------- /ene-jun-2019/practicas/practica_3/README.md: -------------------------------------------------------------------------------- 1 | # Práctica 3 - Práctica pre-examen 2 | 3 | Susana le ecanta jugar Mincecraft, en donde se pasa horas explorando, obteniendo recursos y construyendo cosas. Después de días jugando Susana ya ha acumulado cientos de objetos en su almacén, y quiere que le ayudes a ordenar sus objetos. 4 | 5 | ### Input 6 | 7 | La entrada será recibida por **STDIN** 8 | 9 | La primera linea contine un entero **n** donde **1 <= n <= 50** y representa el número de objetos diferentes que tiene Susana en su almacén. 10 | 11 | Las siguientes líneas tiene un string **s** que representa el nombre del objeto y un entero **1 <= x <= 100**, la cantidad del objeto en el almacén, separados por un espacio donde. 12 | 13 | 14 | ### Output 15 | 16 | Imprime a salida estandar **STDOUT** 17 | 18 | La salida es una línea con los **n** objetos ordenados de mayor a menor. 19 | 20 | ### Ejemplos 21 | 22 | #### Entrada 23 | ``` 24 | 6 25 | RedStone 40 26 | Dirt 60 27 | Books 32 28 | Wood 12 29 | Stone 55 30 | Sand 43 31 | ``` 32 | #### Salida 33 | 34 | ``` 35 | Dirt Stone Sand RedStone Books Wood 36 | ``` 37 | 38 | ### Notas 39 | 40 | Resuelve el problema haciendo una implementación de selection sort, bubble sort o insertion sort. -------------------------------------------------------------------------------- /ene-jun-2024/practicas/parcial_1/README.md: -------------------------------------------------------------------------------- 1 | # Parcial 1 - Mucho Más ordenamiento 2 | 3 | A mi tío Bartolo le encantan los relojes, muchos de los que tiene ya no funcionan y se quedaron con una hora fija en sus manecillas y/o dígitos. Mi tío tiene una fijación muy particular y quiere que los relojes estén acomodados de menor a mayor según la hora que tengan marcados, ayudalo a ordenar sus relojes de esta forma. 4 | 5 | ### Input 6 | 7 | La entrada será recibida por **STDIN** 8 | 9 | Consiste en varias lineas, la primera tiene un entero **n** representado el número de relojes que tiene Bartolo. 10 | 11 | Después hay **n** líneas en la que cada una tiene un string con la hora del reloj x, en formato de 12 hrs con el string PM o AM al final respectivamente. 12 | 13 | ### Output 14 | 15 | Imprime a salida estandar **STDOUT** la lista con los relojes ordenados. 16 | 17 | ### Ejemplos 18 | 19 | #### Entrada 20 | ``` 21 | 6 22 | 01:23 AM 23 | 11:01 PM 24 | 12:54 AM 25 | 09:00 PM 26 | 12:30 PM 27 | 02:12 AM 28 | 29 | 30 | ``` 31 | #### Salida 32 | 33 | ``` 34 | 12:54 AM 35 | 01:23 AM 36 | 02:12 AM 37 | 12:30 PM 38 | 11:01 PM 39 | 09:00 PM 40 | ``` 41 | 42 | ### Notas 43 | 44 | Resuelve el problema haciendo una implementación de MergeSort. -------------------------------------------------------------------------------- /ago-dic-2021/Juan Antonio Cruz Perez/alogritmosCorregidos/Pelis.java: -------------------------------------------------------------------------------- 1 | 2 | public class Pelis { 3 | 4 | public String nombre; 5 | public int hrs; 6 | public int min; 7 | public int dura; 8 | 9 | public Pelis() { 10 | 11 | } 12 | 13 | public Pelis(String nombre, int hrs,int min) { 14 | this.nombre = nombre; 15 | this.hrs = hrs; 16 | this.min = min; 17 | this.dura = (hrs * 60) + min; 18 | } 19 | 20 | 21 | 22 | public String getNombre() { 23 | return nombre; 24 | } 25 | 26 | public void setNombre(String nombre) { 27 | this.nombre = nombre; 28 | } 29 | 30 | public int getHrs() { 31 | return hrs; 32 | } 33 | 34 | public void setHrs(int hrs) { 35 | this.hrs = hrs; 36 | } 37 | 38 | public int getDura() { 39 | return dura; 40 | } 41 | 42 | public void setDura(int dura) { 43 | this.dura = dura; 44 | } 45 | 46 | public int getMin() { 47 | return min; 48 | } 49 | 50 | public void setMin(int min) { 51 | this.min = min; 52 | } 53 | 54 | public String toString() { 55 | return "\n" + nombre; 56 | } 57 | 58 | 59 | 60 | } 61 | -------------------------------------------------------------------------------- /ago-dic-2018/practicas/practica_4/README.md: -------------------------------------------------------------------------------- 1 | # Práctica 4 - Mas ordenamiento 2 | 3 | Juan tiene un montón de libros que quiere leer, y quiere leer la mayor cantidad posible en un año así que empezará a leer sus libros empezando del más corto en adelante. El problema es que toda su biblioteca está desordenada, ayúdalo a ordenarla de menor a mayor tomando en cuenta el número de páginas que tiene cada libro. 4 | 5 | ### Input 6 | 7 | La entrada será recibida por **STDIN** 8 | 9 | Consiste en varias lineas, la primera tiene un entero **n** representado el número de libros que tiene Juan. 10 | 11 | Después hay **n** líneas en la que cada una tiene un string y un entero separados por espacio representando el nombre del libro y el número de páginas que tiene. 12 | 13 | ### Output 14 | 15 | Imprime a salida estandar **STDOUT** la lista con el nombre de los libros ordenados de menor a mayor. 16 | 17 | ### Ejemplos 18 | 19 | #### Entrada 20 | ``` 21 | 5 22 | HarryPotter 245 23 | GodelEscherBach 777 24 | Flatland 96 25 | Mistborn 541 26 | CleanCode 469 27 | 28 | ``` 29 | #### Salida 30 | 31 | ``` 32 | Flatland HarryPotter CleanCode Mistborn GodelEscherBach 33 | ``` 34 | 35 | ### Notas 36 | 37 | Resuelve el problema haciendo una implementación de MergeSort. -------------------------------------------------------------------------------- /ago-dic-2019/practicas/practica5/README.md: -------------------------------------------------------------------------------- 1 | # Practica 5 - Mas ordenamiento 2 | 3 | Juan tiene un montón de libros que quiere leer, y quiere leer la mayor cantidad posible en un año así que empezará a leer sus libros empezando del más corto en adelante. El problema es que toda su biblioteca está desordenada, ayúdalo a ordenarla de menor a mayor tomando en cuenta el número de páginas que tiene cada libro. 4 | 5 | ### Input 6 | 7 | La entrada será recibida por **STDIN** 8 | 9 | Consiste en varias lineas, la primera tiene un entero **n** representado el número de libros que tiene Juan. 10 | 11 | Después hay **n** líneas en la que cada una tiene un string y un entero separados por espacio representando el nombre del libro y el número de páginas que tiene. 12 | 13 | ### Output 14 | 15 | Imprime a salida estandar **STDOUT** la lista con el nombre de los libros ordenados de menor a mayor. 16 | 17 | ### Ejemplos 18 | 19 | #### Entrada 20 | ``` 21 | 5 22 | HarryPotter 245 23 | GodelEscherBach 777 24 | Flatland 96 25 | Mistborn 541 26 | CleanCode 469 27 | 28 | ``` 29 | #### Salida 30 | 31 | ``` 32 | Flatland HarryPotter CleanCode Mistborn GodelEscherBach 33 | ``` 34 | 35 | ### Notas 36 | 37 | Resuelve el problema haciendo una implementación de MergeSort. -------------------------------------------------------------------------------- /ago-dic-2020/practicas/parcial_1.5/README.md: -------------------------------------------------------------------------------- 1 | # Parcial 1 - Mas ordenamiento 2 | 3 | Juan tiene un montón de libros que quiere leer, y quiere leer la mayor cantidad posible en un año así que empezará a leer sus libros empezando del más corto en adelante. El problema es que toda su biblioteca está desordenada, ayúdalo a ordenarla de menor a mayor tomando en cuenta el número de páginas que tiene cada libro. 4 | 5 | ### Input 6 | 7 | La entrada será recibida por **STDIN** 8 | 9 | Consiste en varias lineas, la primera tiene un entero **n** representado el número de libros que tiene Juan. 10 | 11 | Después hay **n** líneas en la que cada una tiene un string y un entero separados por espacio representando el nombre del libro y el número de páginas que tiene. 12 | 13 | ### Output 14 | 15 | Imprime a salida estandar **STDOUT** la lista con el nombre de los libros ordenados de menor a mayor. 16 | 17 | ### Ejemplos 18 | 19 | #### Entrada 20 | ``` 21 | 5 22 | HarryPotter 245 23 | GodelEscherBach 777 24 | Flatland 96 25 | Mistborn 541 26 | CleanCode 469 27 | 28 | ``` 29 | #### Salida 30 | 31 | ``` 32 | Flatland HarryPotter CleanCode Mistborn GodelEscherBach 33 | ``` 34 | 35 | ### Notas 36 | 37 | Resuelve el problema haciendo una implementación de MergeSort. -------------------------------------------------------------------------------- /ago-dic-2021/practicas/practica5/README.md: -------------------------------------------------------------------------------- 1 | # Practica 5 - Mas ordenamiento 2 | 3 | Juan tiene un montón de libros que quiere leer, y quiere leer la mayor cantidad posible en un año así que empezará a leer sus libros empezando del más corto en adelante. El problema es que toda su biblioteca está desordenada, ayúdalo a ordenarla de menor a mayor tomando en cuenta el número de páginas que tiene cada libro. 4 | 5 | ### Input 6 | 7 | La entrada será recibida por **STDIN** 8 | 9 | Consiste en varias lineas, la primera tiene un entero **n** representado el número de libros que tiene Juan. 10 | 11 | Después hay **n** líneas en la que cada una tiene un string y un entero separados por espacio representando el nombre del libro y el número de páginas que tiene. 12 | 13 | ### Output 14 | 15 | Imprime a salida estandar **STDOUT** la lista con el nombre de los libros ordenados de menor a mayor. 16 | 17 | ### Ejemplos 18 | 19 | #### Entrada 20 | ``` 21 | 5 22 | HarryPotter 245 23 | GodelEscherBach 777 24 | Flatland 96 25 | Mistborn 541 26 | CleanCode 469 27 | 28 | ``` 29 | #### Salida 30 | 31 | ``` 32 | Flatland HarryPotter CleanCode Mistborn GodelEscherBach 33 | ``` 34 | 35 | ### Notas 36 | 37 | Resuelve el problema haciendo una implementación de MergeSort. -------------------------------------------------------------------------------- /ago-dic-2018/Guadalupe Alejandro Pérez Camacho/practica_2/Pokimon.java: -------------------------------------------------------------------------------- 1 | package javaapplication5; 2 | import java.util.*; 3 | 4 | public class Pokimon { 5 | public static void main (String[]args){ 6 | Scanner s= new Scanner(System.in); 7 | int n=0,b=0; 8 | while (n<1||n>50) { 9 | System.out.println("Numero de pokemon capturados (de uno a 50)"); 10 | n=s.nextInt(); 11 | } 12 | int a[]=new int[n]; 13 | for (int i = 0; i < a.length; i++) { 14 | while (b<1||b>2000) { 15 | System.out.println("Nivel del pokemon (de uno a dos mil)"); 16 | b=s.nextInt(); 17 | } 18 | a[i]=b; 19 | b=0; 20 | } 21 | for (int i = 1; i < a.length; i++) { 22 | int q=a[i]; 23 | int j=i-1; 24 | while (j!=-1&&q>a[j]) { 25 | a[j+1]=a[j]; 26 | j--; 27 | } 28 | a[j+1]=q; 29 | } 30 | System.out.print("Nivel de los pokemon de mayor a menor \n| "); 31 | for (int i = 0; i < a.length; i++) { 32 | System.out.print(a[i]+" | "); 33 | } 34 | System.out.println(""); 35 | } 36 | 37 | } 38 | -------------------------------------------------------------------------------- /ene-jun-2020/practicas/parcial_1/README.md: -------------------------------------------------------------------------------- 1 | # Parcial 1 - Mucho Más ordenamiento 2 | 3 | A Filomeno le encantan las películas y está organizando un maratón de ciencia ficción en su escuela. Filomeno quiere que las pelis se proyecten de la más corta a la más larga, en el caso de que duren lo mismo entonces ordenarlas por orden alfabético, ayudalo a ordenar sus películas de esta forma. 4 | 5 | ### Input 6 | 7 | La entrada será recibida por **STDIN** 8 | 9 | Consiste en varias lineas, la primera tiene un entero **n** representado el número de películas que usará Filomeno. 10 | 11 | Después hay **n** líneas en la que cada una tiene un string y un dos enteros separados por espacio representando el nombre de la película, el número de horas y minutos que tiene. 12 | 13 | ### Output 14 | 15 | Imprime a salida estandar **STDOUT** la lista con el nombre de las películas ordenadas de menor a mayor. 16 | 17 | ### Ejemplos 18 | 19 | #### Entrada 20 | ``` 21 | 5 22 | StarWars 2 1 23 | Alien 1 57 24 | ASpaceOdyssey 2 41 25 | Matrix 2 30 26 | BladeRunner 1 57 27 | 28 | ``` 29 | #### Salida 30 | 31 | ``` 32 | Alien BladeRunner StarWars Matrix ASpaceOdyssey 33 | ``` 34 | 35 | ### Notas 36 | 37 | Resuelve el problema haciendo una implementación de cualquier algoritmo visto en clase. -------------------------------------------------------------------------------- /ago-dic-2024/practicas/practica_5/README.md: -------------------------------------------------------------------------------- 1 | # Practica 5 - Mas ordenamiento 2 | 3 | Juan tiene un montón de libros que quiere leer, y quiere leer la mayor cantidad posible en un año así que empezará a leer sus libros empezando del más corto en adelante. El problema es que toda su biblioteca está desordenada, ayúdalo a ordenarla de menor a mayor tomando en cuenta el número de páginas que tiene cada libro. 4 | 5 | ### Input 6 | 7 | La entrada será recibida por **STDIN** 8 | 9 | Consiste en varias lineas, la primera tiene un entero **n** representado el número de libros que tiene Juan. 10 | 11 | Después hay **n** líneas en la que cada una tiene un string y un entero separados por espacio representando el nombre del libro y el número de páginas que tiene. 12 | 13 | ### Output 14 | 15 | Imprime a salida estandar **STDOUT** la lista con el nombre de los libros ordenados de menor a mayor. 16 | 17 | ### Ejemplos 18 | 19 | #### Entrada 20 | 21 | ``` 22 | 5 23 | HarryPotter 245 24 | GodelEscherBach 777 25 | Flatland 96 26 | Mistborn 541 27 | CleanCode 469 28 | 29 | ``` 30 | 31 | #### Salida 32 | 33 | ``` 34 | Flatland HarryPotter CleanCode Mistborn GodelEscherBach 35 | ``` 36 | 37 | ### Notas 38 | 39 | Resuelve el problema haciendo una implementación de MergeSort. 40 | 41 | -------------------------------------------------------------------------------- /ago-dic-2018/slides/divide-conquer/merge.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | var MAX = 2000000 6 | 7 | // start merge OMIT 8 | func merge(arr []int, start int, middle int, end int) { 9 | leftSize := middle - start + 1 10 | rightSize := end - middle 11 | L := make([]int, leftSize+1) 12 | for i := 0; i < leftSize; i++ { 13 | L[i] = arr[start+i] 14 | } 15 | R := make([]int, rightSize+1) 16 | for j := 0; j < rightSize; j++ { 17 | R[j] = arr[middle+1+j] 18 | } 19 | L[leftSize] = MAX 20 | R[rightSize] = MAX 21 | i := 0 22 | j := 0 23 | for k := start; k <= end; k++ { 24 | if L[i] <= R[j] { 25 | arr[k] = L[i] 26 | i++ 27 | } else { 28 | arr[k] = R[j] 29 | j++ 30 | } 31 | } 32 | } 33 | 34 | // end merge OMIT 35 | 36 | // start mergeSort OMIT 37 | func mergeSort(arr []int, start int, end int) { 38 | if start != end { 39 | middle := (start + end) / 2 40 | mergeSort(arr, start, middle) 41 | mergeSort(arr, middle+1, end) 42 | merge(arr, start, middle, end) 43 | } 44 | } 45 | 46 | // end mergeSort OMIT 47 | 48 | // start main OMIT 49 | func main() { 50 | arr := []int{324, 6, 334, 5, 7, 34, 123, 43, 3, 1, 5, 47, 67, 75, 76, 76, 757, 675} 51 | mergeSort(arr, 0, len(arr)-1) 52 | 53 | fmt.Println(arr) 54 | } 55 | 56 | // end main OMIT 57 | -------------------------------------------------------------------------------- /ene-jun-2021/material/algoritmos/bfs.py: -------------------------------------------------------------------------------- 1 | N, E = list(map(int, input().split())) 2 | 3 | adj_list = [list() for x in range(N)] 4 | 5 | for x in range(E): 6 | n1, n2 = list(map(int, input().split())) 7 | adj_list[n1].append(n2) 8 | adj_list[n2].append(n1) 9 | 10 | print(adj_list) 11 | 12 | 13 | def BFS(grafo, inicio): 14 | queue = [] 15 | visited = [False] * len(grafo) 16 | pasos = [0] * len(grafo) 17 | 18 | visited[inicio] = True 19 | queue.append(inicio) 20 | while len(queue) > 0: 21 | actual = queue.pop(0) 22 | # print(actual) 23 | for vecino in grafo[actual]: 24 | if visited[vecino]: 25 | continue 26 | else: 27 | visited[vecino] = True 28 | queue.append(vecino) 29 | pasos[vecino] = pasos[actual] + 1 30 | 31 | # print(pasos) 32 | # print(list(range(len(grafo)))) 33 | 34 | BFS(adj_list, 0) 35 | 36 | 37 | 38 | print("-------DFS-------") 39 | visited = [False] * len(adj_list) 40 | def DFS(grafo, actual): 41 | print("estoy en", actual) 42 | for vecino in grafo[actual]: 43 | if not visited[vecino]: 44 | visited[vecino] = True 45 | DFS(grafo, vecino) 46 | 47 | visited[0] = True 48 | DFS(adj_list, 0) -------------------------------------------------------------------------------- /ago-dic-2018/practicas/practica_2/README.md: -------------------------------------------------------------------------------- 1 | # Práctica 2 - Insertion Sort 2 | 3 | En su último viaje a Ciudad de México Carlitos capturó un montón de Pokemons en Pokemon go. 4 | Y quiere ver todos esos pokemons del más poderoso al más debil. 5 | 6 | Carlitos tiene una lista con **n** enteros representando el poder de cada Pokemon (CP). 7 | Y como tú eres su amigo *que le sabe a eso de las compus* te pidió que hicieras un programa 8 | que le regrese la una lista de los pokemons de mayor a menor. 9 | 10 | ### Input 11 | 12 | La entrada será recibida por **STDIN** 13 | 14 | La entrada consiste en dos lineas donde la primera contine un entero **n** donde **1 <= n <= 50** y 15 | representa el número de pokemons que capturó Carlitos. 16 | 17 | La segunda línea tiene *n* enteros **ni** separados por un espacio donde 18 | **1 <= ni <= 2000** 19 | 20 | ### Output 21 | 22 | Imprime a salida estandar **STDOUT** 23 | 24 | La salida es una línea con los **n** enteros separados por un espacio ordenados de mayor a menor 25 | 26 | ### Ejemplos 27 | 28 | #### Entrada 29 | ``` 30 | 5 31 | 1432 230 1980 1689 400 32 | ``` 33 | #### Salida 34 | 35 | ``` 36 | 1980 1689 1432 400 230 37 | ``` 38 | 39 | ### Notas 40 | 41 | Resuelve el problema haciendo una implementación de insertion sort -------------------------------------------------------------------------------- /ago-dic-2020/practicas/practica3/README.md: -------------------------------------------------------------------------------- 1 | # Práctica 3 - Insertion Sort 2 | 3 | En su último viaje a Ciudad de México Carlitos capturó un montón de Pokemons en Pokemon go. 4 | Y quiere ver todos esos pokemons del más poderoso al más debil. 5 | 6 | Carlitos tiene una lista con **n** enteros representando el poder de cada Pokemon (CP). 7 | Y como tú eres su amigo *que le sabe a eso de las compus* te pidió que hicieras un programa 8 | que le regrese la una lista de los pokemons de mayor a menor. 9 | 10 | ### Input 11 | 12 | La entrada será recibida por **STDIN** 13 | 14 | La entrada consiste en dos lineas donde la primera contine un entero **n** donde **1 <= n <= 50** y 15 | representa el número de pokemons que capturó Carlitos. 16 | 17 | La segunda línea tiene *n* enteros **ni** separados por un espacio donde 18 | **1 <= ni <= 2000** 19 | 20 | ### Output 21 | 22 | Imprime a salida estandar **STDOUT** 23 | 24 | La salida es una línea con los **n** enteros separados por un espacio ordenados de mayor a menor 25 | 26 | ### Ejemplos 27 | 28 | #### Entrada 29 | ``` 30 | 5 31 | 1432 230 1980 1689 400 32 | ``` 33 | #### Salida 34 | 35 | ``` 36 | 1980 1689 1432 400 230 37 | ``` 38 | 39 | ### Notas 40 | 41 | Resuelve el problema haciendo una implementación de insertion sort -------------------------------------------------------------------------------- /ago-dic-2023/practicas/practica3/README.md: -------------------------------------------------------------------------------- 1 | # Práctica 3 - Selection Sort 2 | 3 | En su último viaje a Ciudad de México Carlitos capturó un montón de Pokemons en Pokemon go. 4 | Y quiere ver todos esos pokemons del más poderoso al más debil. 5 | 6 | Carlitos tiene una lista con **n** enteros representando el poder de cada Pokemon (CP). 7 | Y como tú eres su amigo *que le sabe a eso de las compus* te pidió que hicieras un programa 8 | que le regrese la una lista de los pokemons de mayor a menor. 9 | 10 | ### Input 11 | 12 | La entrada será recibida por **STDIN** 13 | 14 | La entrada consiste en dos lineas donde la primera contine un entero **n** donde **1 <= n <= 50** y 15 | representa el número de pokemons que capturó Carlitos. 16 | 17 | La segunda línea tiene *n* enteros **ni** separados por un espacio donde 18 | **1 <= ni <= 2000** 19 | 20 | ### Output 21 | 22 | Imprime a salida estandar **STDOUT** 23 | 24 | La salida es una línea con los **n** enteros separados por un espacio ordenados de mayor a menor 25 | 26 | ### Ejemplos 27 | 28 | #### Entrada 29 | ``` 30 | 5 31 | 1432 230 1980 1689 400 32 | ``` 33 | #### Salida 34 | 35 | ``` 36 | 1980 1689 1432 400 230 37 | ``` 38 | 39 | ### Notas 40 | 41 | Resuelve el problema haciendo una implementación de selection sort -------------------------------------------------------------------------------- /ago-dic-2022/practicas/practica3/README.md: -------------------------------------------------------------------------------- 1 | # Práctica 3 - Ordenando Pokemons 2 | 3 | En su último viaje a Ciudad de México Carlitos capturó un montón de Pokemons en Pokemon go. 4 | Y quiere ver todos esos pokemons del más poderoso al más debil. 5 | 6 | Carlitos tiene una lista con **n** enteros representando el poder de cada Pokemon (CP). 7 | Y como tú eres su amigo *que le sabe a eso de las compus* te pidió que hicieras un programa 8 | que le regrese la una lista de los pokemons de mayor a menor. 9 | 10 | ### Input 11 | 12 | La entrada será recibida por **STDIN** 13 | 14 | La entrada consiste en dos lineas donde la primera contine un entero **n** donde **1 <= n <= 50** y 15 | representa el número de pokemons que capturó Carlitos. 16 | 17 | La segunda línea tiene *n* enteros **ni** separados por un espacio donde 18 | **1 <= ni <= 2000** 19 | 20 | ### Output 21 | 22 | Imprime a salida estandar **STDOUT** 23 | 24 | La salida es una línea con los **n** enteros separados por un espacio ordenados de mayor a menor 25 | 26 | ### Ejemplos 27 | 28 | #### Entrada 29 | ``` 30 | 5 31 | 1432 230 1980 1689 400 32 | ``` 33 | #### Salida 34 | 35 | ``` 36 | 1980 1689 1432 400 230 37 | ``` 38 | 39 | ### Notas 40 | 41 | Resuelve el problema haciendo una implementación de selection sort o bubble sort -------------------------------------------------------------------------------- /ene-jun-2023/practicas/practica4/README.md: -------------------------------------------------------------------------------- 1 | # Práctica 4 - Ordenando Pokemons 2 | 3 | En su último viaje a Ciudad de México Carlitos capturó un montón de Pokemons en Pokemon go. 4 | Y quiere ver todos esos pokemons del más poderoso al más debil. 5 | 6 | Carlitos tiene una lista con **n** enteros representando el poder de cada Pokemon (CP). 7 | Y como tú eres su amigo *que le sabe a eso de las compus* te pidió que hicieras un programa 8 | que le regrese la una lista de los pokemons de mayor a menor. 9 | 10 | ### Input 11 | 12 | La entrada será recibida por **STDIN** 13 | 14 | La entrada consiste en dos lineas donde la primera contine un entero **n** donde **1 <= n <= 50** y 15 | representa el número de pokemons que capturó Carlitos. 16 | 17 | La segunda línea tiene *n* enteros **ni** separados por un espacio donde 18 | **1 <= ni <= 2000** 19 | 20 | ### Output 21 | 22 | Imprime a salida estandar **STDOUT** 23 | 24 | La salida es una línea con los **n** enteros separados por un espacio ordenados de mayor a menor 25 | 26 | ### Ejemplos 27 | 28 | #### Entrada 29 | ``` 30 | 5 31 | 1432 230 1980 1689 400 32 | ``` 33 | #### Salida 34 | 35 | ``` 36 | 1980 1689 1432 400 230 37 | ``` 38 | 39 | ### Notas 40 | 41 | Resuelve el problema haciendo una implementación de selection sort o bubble sort -------------------------------------------------------------------------------- /ene-jun-2024/practicas/practica3/README.md: -------------------------------------------------------------------------------- 1 | # Práctica 3 - Ordenando 2 | 3 | Chuy está estudiando para ser doctor y batalla mucho con los nombres tan extraños que tienen las medicinas, algunos de esos nombres pueden ser muy largos, como *CANDESARTAN HIDROCLOROTIAZIDA ALTER*, Chuy tiene una lista con nombres de medicamentos y quiere ordenarla de los nombres más cortos a los más largos para así estudiarla mejor. 4 | 5 | Ayuda a Chuy haciendo un programa que haga eso. 6 | 7 | ### Input 8 | 9 | La entrada será recibida por **STDIN** 10 | 11 | Consiste en una linea con un entero **n**, el número de medicinas, donde **1 <= n <= 100**. Seguido de **n** lineas con el nombre de una medicina. 12 | 13 | ### Output 14 | 15 | Imprime a salida estandar **STDOUT**, la lista de los medicamentos ordenados de más corto a más largo. 16 | 17 | ### Ejemplos 18 | 19 | #### Entrada 20 | ``` 21 | 7 22 | CANDESARTAN HIDROCLOROTIAZIDA ALTER 23 | CARBAMAZEPINA NORMON 24 | MATRIF 25 | ACICLOVIR SANDOZ 26 | MELOXICAM 27 | FENDIVIA 28 | SEBUMSELEN 29 | ``` 30 | #### Salida 31 | 32 | ``` 33 | MATRIF 34 | FENDIVIA 35 | MELOXICAM 36 | SEBUMSELEN 37 | ACICLOVIR SANDOZ 38 | CARBAMAZEPINA NORMON 39 | CANDESARTAN HIDROCLOROTIAZIDA ALTER 40 | ``` 41 | 42 | ### Notas 43 | 44 | Resuelve el problema haciendo una implementación de selection sort o bubble sort. -------------------------------------------------------------------------------- /ago-dic-2024/practicas/practica_3/README.md: -------------------------------------------------------------------------------- 1 | # Práctica 3 - Ordenando Pokemons 2 | 3 | En su último viaje a Ciudad de México Carlitos capturó un montón de Pokemons en Pokemon go. 4 | Y quiere ver todos esos pokemons del más poderoso al más debil. 5 | 6 | Carlitos tiene una lista con **n** enteros representando el poder de cada Pokemon (CP). 7 | Y como tú eres su amigo _que le sabe a eso de las compus_ te pidió que hicieras un programa 8 | que le regrese la una lista de los pokemons de mayor a menor. 9 | 10 | ### Input 11 | 12 | La entrada será recibida por **STDIN** 13 | 14 | La entrada consiste en dos lineas donde la primera contine un entero **n** donde **1 <= n <= 50** y 15 | representa el número de pokemons que capturó Carlitos. 16 | 17 | La segunda línea tiene _n_ enteros **ni** separados por un espacio donde 18 | **1 <= ni <= 2000** 19 | 20 | ### Output 21 | 22 | Imprime a salida estandar **STDOUT** 23 | 24 | La salida es una línea con los **n** enteros separados por un espacio ordenados de mayor a menor 25 | 26 | ### Ejemplos 27 | 28 | #### Entrada 29 | 30 | ``` 31 | 5 32 | 1432 230 1980 1689 400 33 | ``` 34 | 35 | #### Salida 36 | 37 | ``` 38 | 1980 1689 1432 400 230 39 | ``` 40 | 41 | ### Notas 42 | 43 | Resuelve el problema haciendo una implementación de selection sort o bubble sort 44 | 45 | -------------------------------------------------------------------------------- /ene-jun-2021/practicas/practica7/README.md: -------------------------------------------------------------------------------- 1 | # Práctica 7 - Exposición 2 | En la exposición tienen que explicar el algoritmo de forma sencilla o con las manos, (con ejemplos de cartas, números, etc). 3 | 4 | Presentar luego una explicación más formal, con pseudocódigo o diagramas de flujo, etc. 5 | 6 | Y luego presentar y explicar un ejemplo con código. Para que todos podamos entender el algoritmo e implementarlo. 7 | 8 | Si traen alguna dinámica mucho mejor. 9 | 10 | 11 | ## Equipos y fechas de exposición: 12 | ### Viernes 16: 13 | - 1 Shell Sort 14 | - Karla Sarabi Gallegos 15 | - ORDAZ SALAZAR TOMAS ANTONIO 16 | - 2 Heap Sort 17 | - ASCACIO SANCHEZ JORGE LUIS 18 | - MORENO MORALES YAHAIRA ELIZABETH 19 | - PINTOR CORREA ITZEL CECILIA 20 | ### Lunes 19: 21 | - 3 Counting Sort 22 | - RODRIGUEZ RODRIGUEZ FERNANDA 23 | - SAUCEDA GARAY ANAHI GABRIELA 24 | - 4 Radix Sort 25 | - Jose Adrian 26 | - Ernesto Burciaga 27 | - Andrea Horizel Garcia 28 | 29 | ### Viernes 23: 30 | - 5 Bucket Sort 31 | - Juan Jaime Reyes 32 | - Karina Alejandra Treviño 33 | 34 | ## Lista de personas que necesitan reportarse para que se les asigne un equipo (no sé si siguen viniendo a la clase): 35 | - AYALA ORNELAS IVAN 36 | - RIVAS RODRIGUEZ JOSE JAVIER 37 | - RUIZ GARCIA SAUL HASSAN 38 | - SILVA TORRES LIZBETH YUVISELA -------------------------------------------------------------------------------- /ene-jun-2020/practicas/practica3/README.md: -------------------------------------------------------------------------------- 1 | # Práctica 3 - Ordenando 2 | 3 | Chuy está estudiando para ser doctor y batalla mucho con los nombres tan extraños que tienen las medicinas, algunos de esos nombres pueden ser muy largos, como *CANDESARTAN HIDROCLOROTIAZIDA ALTER*, Chuy tiene una lista con nombres de medicamentos y quiere ordenarla de los nombres más cortos a los más largos para así estudiarla mejor. 4 | 5 | Ayuda a Chuy haciendo un programa que haga eso. 6 | 7 | ### Input 8 | 9 | La entrada será recibida por **STDIN** 10 | 11 | Consiste en una linea con un entero **n**, el número de medicinas, donde **1 <= n <= 100**. Seguido de **n** lineas con el nombre de una medicina. 12 | 13 | ### Output 14 | 15 | Imprime a salida estandar **STDOUT**, la lista de los medicamentos ordenados de más corto a más largo. 16 | 17 | ### Ejemplos 18 | 19 | #### Entrada 20 | ``` 21 | 7 22 | CANDESARTAN HIDROCLOROTIAZIDA ALTER 23 | CARBAMAZEPINA NORMON 24 | MATRIF 25 | ACICLOVIR SANDOZ 26 | MELOXICAM 27 | FENDIVIA 28 | SEBUMSELEN 29 | ``` 30 | #### Salida 31 | 32 | ``` 33 | MATRIF 34 | FENDIVIA 35 | MELOXICAM 36 | SEBUMSELEN 37 | ACICLOVIR SANDOZ 38 | CARBAMAZEPINA NORMON 39 | CANDESARTAN HIDROCLOROTIAZIDA ALTER 40 | ``` 41 | 42 | ### Notas 43 | 44 | Resuelve el problema haciendo una implementación de cualquier algoritmo de ordenamiento que hemos visto en clase. -------------------------------------------------------------------------------- /ene-jun-2022/practicas/practica4/README.md: -------------------------------------------------------------------------------- 1 | # Práctica 4 - Ordenando 2 | 3 | Chuy está estudiando para ser doctor y batalla mucho con los nombres tan extraños que tienen las medicinas, algunos de esos nombres pueden ser muy largos, como *CANDESARTAN HIDROCLOROTIAZIDA ALTER*, Chuy tiene una lista con nombres de medicamentos y quiere ordenarla de los nombres más cortos a los más largos para así estudiarla mejor. 4 | 5 | Ayuda a Chuy haciendo un programa que haga eso. 6 | 7 | ### Input 8 | 9 | La entrada será recibida por **STDIN** 10 | 11 | Consiste en una linea con un entero **n**, el número de medicinas, donde **1 <= n <= 100**. Seguido de **n** lineas con el nombre de una medicina. 12 | 13 | ### Output 14 | 15 | Imprime a salida estandar **STDOUT**, la lista de los medicamentos ordenados de más corto a más largo. 16 | 17 | ### Ejemplos 18 | 19 | #### Entrada 20 | ``` 21 | 7 22 | CANDESARTAN HIDROCLOROTIAZIDA ALTER 23 | CARBAMAZEPINA NORMON 24 | MATRIF 25 | ACICLOVIR SANDOZ 26 | MELOXICAM 27 | FENDIVIA 28 | SEBUMSELEN 29 | ``` 30 | #### Salida 31 | 32 | ``` 33 | MATRIF 34 | FENDIVIA 35 | MELOXICAM 36 | SEBUMSELEN 37 | ACICLOVIR SANDOZ 38 | CARBAMAZEPINA NORMON 39 | CANDESARTAN HIDROCLOROTIAZIDA ALTER 40 | ``` 41 | 42 | ### Notas 43 | 44 | Resuelve el problema haciendo una implementación de cualquier algoritmo de ordenamiento que hemos visto en clase. -------------------------------------------------------------------------------- /ene-jun-2023/practicas/practica3/README.md: -------------------------------------------------------------------------------- 1 | # Práctica 3 - Ordenando 2 | 3 | Chuy está estudiando para ser doctor y batalla mucho con los nombres tan extraños que tienen las medicinas, algunos de esos nombres pueden ser muy largos, como *CANDESARTAN HIDROCLOROTIAZIDA ALTER*, Chuy tiene una lista con nombres de medicamentos y quiere ordenarla de los nombres más cortos a los más largos para así estudiarla mejor. 4 | 5 | Ayuda a Chuy haciendo un programa que haga eso. 6 | 7 | ### Input 8 | 9 | La entrada será recibida por **STDIN** 10 | 11 | Consiste en una linea con un entero **n**, el número de medicinas, donde **1 <= n <= 100**. Seguido de **n** lineas con el nombre de una medicina. 12 | 13 | ### Output 14 | 15 | Imprime a salida estandar **STDOUT**, la lista de los medicamentos ordenados de más corto a más largo. 16 | 17 | ### Ejemplos 18 | 19 | #### Entrada 20 | ``` 21 | 7 22 | CANDESARTAN HIDROCLOROTIAZIDA ALTER 23 | CARBAMAZEPINA NORMON 24 | MATRIF 25 | ACICLOVIR SANDOZ 26 | MELOXICAM 27 | FENDIVIA 28 | SEBUMSELEN 29 | ``` 30 | #### Salida 31 | 32 | ``` 33 | MATRIF 34 | FENDIVIA 35 | MELOXICAM 36 | SEBUMSELEN 37 | ACICLOVIR SANDOZ 38 | CARBAMAZEPINA NORMON 39 | CANDESARTAN HIDROCLOROTIAZIDA ALTER 40 | ``` 41 | 42 | ### Notas 43 | 44 | Resuelve el problema haciendo una implementación de cualquier algoritmo de ordenamiento que hemos visto en clase. -------------------------------------------------------------------------------- /ene-jun-2021/material/algoritmos/mergesort.py: -------------------------------------------------------------------------------- 1 | def Merge(sorted_left_array, sorted_right_array): 2 | arr_resultado = [] 3 | while len(sorted_left_array) > 0 and len(sorted_right_array) > 0: 4 | if sorted_left_array[0] > sorted_right_array[0]: 5 | arr_resultado.append(sorted_right_array[0]) 6 | sorted_right_array.pop(0) 7 | else: 8 | arr_resultado.append(sorted_left_array[0]) 9 | sorted_left_array.pop(0) 10 | 11 | while len(sorted_left_array) > 0: 12 | arr_resultado.append(sorted_left_array[0]) 13 | sorted_left_array.pop(0) 14 | 15 | while len(sorted_right_array) > 0: 16 | arr_resultado.append(sorted_right_array[0]) 17 | sorted_right_array.pop(0) 18 | 19 | return arr_resultado 20 | 21 | def mergeSort(arr): 22 | if len(arr) == 1: 23 | return arr 24 | 25 | middle = len(arr) // 2 26 | left_array = arr[:middle] 27 | right_array = arr[middle:] 28 | 29 | sorted_left_array = mergeSort(left_array) 30 | sorted_right_array = mergeSort(right_array) 31 | 32 | return Merge(sorted_left_array, sorted_right_array) 33 | 34 | 35 | 36 | arr = [1, 4,56,564,2,7,321,12,56,568,32,23,567,568,2,21,753,6] 37 | arrNombre = ["mipeli1", "peli2", "peli3"] 38 | 39 | print(arr) 40 | arr2 = mergeSort(arr, arrNombre) 41 | print(arr2) -------------------------------------------------------------------------------- /ene-jun-2019/practicas/practica_2/README.md: -------------------------------------------------------------------------------- 1 | # Práctica 2 - Insertion Sort 2 | 3 | Juan es un fanático de las hamburguesas de queso, tanto así que se dedicó todas las vacaciones a clasificar las hamburguesas de diferentes lugares en el país. Al finál terminó con una lista de puntuación para cada hamburguesa que probó y ahora quiere ver todas las puntuaciones de mejor a peor. 4 | 5 | Juan tiene una lista con **n** enteros representando la calificación de cada hamburguesa. 6 | Y como tú eres su amigo *que le sabe a eso de las compus* te pidió que hicieras un programa 7 | que le regrese la lista ordenada de mayor a menor. 8 | 9 | ### Input 10 | 11 | La entrada será recibida por **STDIN** 12 | 13 | La entrada consiste en dos lineas donde la primera contine un entero **n** donde **1 <= n <= 50** y 14 | representa el número de hamburguesas que Juan calificó. 15 | 16 | La segunda línea tiene *n* enteros **ni** separados por un espacio donde 17 | **0 <= ni <= 100** 18 | 19 | ### Output 20 | 21 | Imprime a salida estandar **STDOUT** 22 | 23 | La salida es una línea con los **n** enteros separados por un espacio ordenados de mayor a menor 24 | 25 | ### Ejemplos 26 | 27 | #### Entrada 28 | ``` 29 | 5 30 | 32 23 10 95 42 31 | ``` 32 | #### Salida 33 | 34 | ``` 35 | 95 42 32 23 10 36 | ``` 37 | 38 | ### Notas 39 | 40 | Resuelve el problema haciendo una implementación de insertion sort -------------------------------------------------------------------------------- /ago-dic-2018/Pérez Sánchez José Jahir/Practica 2/Pokemon.java: -------------------------------------------------------------------------------- 1 | package algoritmos; 2 | import java.util.Scanner; 3 | public class Pokemon { 4 | public static void main(String[] args) { 5 | Scanner sc = new Scanner(System.in); 6 | int p=0,cp=0; 7 | System.out.println("¿Cuantos pokemon atrapo Carlitos?"); 8 | p=sc.nextInt(); 9 | if(p>50 || p<1){ 10 | System.out.println("Valor no valido"); 11 | } 12 | int [] pokemon=new int[p]; 13 | System.out.println("¿Cual es el CP de tus pokemon?"); 14 | for (int i = 0; i < pokemon.length; i++) { 15 | cp=sc.nextInt(); 16 | if(cp>2000 || cp<1){ 17 | System.out.println("CP no valido"); 18 | } 19 | pokemon[i]=cp; 20 | } 21 | System.out.println(pokemon.length); 22 | for (int i = 0; i < pokemon.length; i++) { 23 | System.out.print(pokemon[i]+"\t"); 24 | } 25 | int q; 26 | int j; 27 | for (int i = 1; i < pokemon.length; i++) { 28 | q=pokemon[i]; 29 | j=i-1; 30 | while( j>=0 && q>pokemon[j]){ 31 | pokemon[j+1]=pokemon[j]; 32 | j--; 33 | } 34 | pokemon[j+1]=q; 35 | } 36 | System.out.println(""); 37 | for (int i = 0; i < pokemon.length; i++) { 38 | System.out.print(pokemon[i]+"\t"); 39 | } 40 | 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /ago-dic-2018/David Sena Martinez/Practica-3/Dinos.java: -------------------------------------------------------------------------------- 1 | 2 | package algoritmos; 3 | import java.util.Scanner; 4 | public class Dinos { 5 | 6 | public static void main(String[] args) { 7 | Scanner sc= new Scanner (System.in); 8 | String nombre_dino =""; 9 | int numero=0; 10 | System.out.println("Numero de Dinos"); 11 | numero=sc.nextInt(); 12 | 13 | String [] NOMBRE= new String [numero+1]; 14 | System.out.println("Nombre de Cada Dinosaurio:"); 15 | 16 | for (int i = 0; i < NOMBRE.length; i++) { 17 | nombre_dino=sc.nextLine(); 18 | NOMBRE[i]=nombre_dino; 19 | } 20 | for (int i = 0; i < NOMBRE.length; i++) { 21 | System.out.println(NOMBRE[i]); 22 | } 23 | //IMLEMENTO ALGORITMO BUBBLE SORT 24 | for (int i = 0; i 0){ 20 | if(inicio==mid){ 21 | return -1; 22 | } 23 | if(a[mid-1].compareToIgnoreCase(dato)== 0){ 24 | return mid-1; 25 | } 26 | return Encuentra(a,inicio,mid-1,dato); 27 | } 28 | if(a[mid].compareToIgnoreCase(dato)<0){ 29 | return Encuentra(a,mid+1,termina,dato); 30 | } 31 | return -1; 32 | } 33 | 34 | public static void main(String[] args) { 35 | Scanner sc = new Scanner(System.in); 36 | String a[]={"a", "a12", "b2", "text2", "text2a", "text2a2"}; 37 | String encu=""; 38 | encu=sc.nextLine(); 39 | for (int i = 0; i < a.length; i++) { 40 | System.out.print(a[i]+"\t"); 41 | } 42 | System.out.println("\n"); 43 | System.out.println(Encuentra(a,0,a.length,encu)); 44 | } 45 | 46 | } 47 | -------------------------------------------------------------------------------- /ago-dic-2018/Guadalupe Alejandro Pérez Camacho/practica_6/BusquedaBinaria.java: -------------------------------------------------------------------------------- 1 | /* 2 | * To change this license header, choose License Headers in Project Properties. 3 | * To change this template file, choose Tools | Templates 4 | * and open the template in the editor. 5 | */ 6 | package javaapplication5; 7 | import java.util.*; 8 | /** 9 | * 10 | * @author Acer 11 | */ 12 | public class BusquedaBinaria { 13 | public static void main(String[]args){ 14 | Scanner s= new Scanner(System.in); 15 | String [] ss=s.nextLine().split(" "); 16 | int n=Integer.parseInt(ss[0]); 17 | String b=ss[1]; 18 | String a [] = new String[n]; 19 | ss=s.nextLine().split(" "); 20 | for (int i = 0; i < a.length; i++) { 21 | a [i] = ss[i]; 22 | } 23 | System.out.println(busquedaBinaria(a,b,0,a.length)); 24 | } 25 | public static int busquedaBinaria(String a[],String n,int Low,int High){ 26 | if (High < Low) 27 | return -1; //Caso base. No se encuentra el elemento 28 | else { 29 | int middle = (Low+High) / 2; 30 | if (n.compareTo(a[middle])<0&&n.length()0&&n.length()>a[middle].length()) 33 | return busquedaBinaria(a, n, middle + 1, High); 34 | else 35 | return middle+1; //Case base. Posicion del elemento 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /ene-jun-2019/practicas/practica_10/README.md: -------------------------------------------------------------------------------- 1 | # Práctica 10 - Muchas posibilidades 2 | 3 | Alex es un fan del juego de rol, y tiene un montón de dados, d4, d6, d8, d10, d20, etc, etc, etc. 4 | 5 | Tiene tantos dados con tantas caras que se plantea un pequeño desafío. 6 | 7 | Tomando **n** dados, cada uno con **m** caras, todas las caras numeradas desde el **1** hasta **m**. Al momento de lanzar todos, de cuántas formas diferentes se puede obtener la suma **x**. 8 | 9 | Por ejemplo lanzando 2 dados de 2 caras (como una moneda), solo hay dos formas para obtener 3 de resultado: 10 | 11 | [1, 2] y [2, 1] 12 | 13 | ### Input 14 | 15 | La entrada será recibida por **STDIN** 16 | 17 | Consiste en una linea de 3 enteros separados por espacios, el número de dados **n**, el número de caras por dado **m** y la suma **x** que se desea optener. 18 | 19 | ### Output 20 | 21 | Imprime a salida estandar **STDOUT** el número de diferentes formas para obtener **x**. Considera que si no se puede obtener esa suma, el resultado es 0. 22 | 23 | ### Ejemplos 24 | 25 | #### Entrada 26 | ``` 27 | 2 2 3 28 | ``` 29 | #### Salida 30 | 31 | ``` 32 | 2 33 | ``` 34 | #### Entrada 35 | ``` 36 | 6 3 8 37 | ``` 38 | #### Salida 39 | 40 | ``` 41 | 21 42 | ``` 43 | #### Entrada 44 | ``` 45 | 4 2 5 46 | ``` 47 | #### Salida 48 | 49 | ``` 50 | 4 51 | ``` 52 | #### Entrada 53 | ``` 54 | 4 3 5 55 | ``` 56 | #### Salida 57 | 58 | ``` 59 | 6 60 | ``` 61 | 62 | ### Detalles 63 | Piensa en el cómo resolvimos el problema de la tortuga en clase para tratar de formular el algoritmo. -------------------------------------------------------------------------------- /ago-dic-2021/Juan Antonio Cruz Perez/parcial 1/SelectionSortDinosaurios.java: -------------------------------------------------------------------------------- 1 | package practicas; 2 | 3 | import java.util.Scanner; 4 | 5 | public class SelectionSortDinosaurios { 6 | 7 | public static void main(String[] args) { 8 | String s = " ", n = " "; 9 | Scanner l = new Scanner(System.in); 10 | //cuantos problemas tiene 11 | /*inserto los dinosaurios separados por espacio en una cadena 12 | */ 13 | s = l.nextLine(); 14 | String[] dino = s.split("\\s+"); 15 | //total de probleas 16 | //n = (dino[0]); 17 | for (int i = 0; i < dino.length; i++) { 18 | System.out.println(dino[i]); 19 | } 20 | 21 | 22 | 23 | System.out.println("Ordenamiento -------"); 24 | int aux=0; 25 | for (int i = 0; i < dino.length; i++) { 26 | String mP = dino[i]; 27 | for (int j = i+1; j < dino.length; j++) { 28 | if (mP.length() < dino[j].length()) { 29 | continue; 30 | } 31 | if(dino[j].length() < mP.length()) 32 | mP = dino[j]; 33 | aux = j; 34 | } 35 | dino[aux]= dino[i]; 36 | dino[i]= mP; 37 | } 38 | 39 | // for (int i = a.length-1; i >=0; i--) { 40 | // System.out.println(a[i]); 41 | // } 42 | 43 | for (int i = dino.length-1; i >= 0; i--) { 44 | System.out.println(dino[i]); 45 | } 46 | 47 | 48 | } 49 | } 50 | -------------------------------------------------------------------------------- /ene-jun-2019/practicas/practica_9/README.md: -------------------------------------------------------------------------------- 1 | # Práctica 9 - Camino más corto para llegar temprano 2 | 3 | A Juanito siempre se le dificulta despertarse temprano, y dependiendo de la hora a la que se despierta hay tráfico por algunas rutas camino a su trabajo. Ayúdalo haciendo un programa que tome las calles con el nivel de trafico de cada una y muestre la ruta que debe de tomar para llegar lo más pronto posible a su oficina. 4 | 5 | ### Input 6 | 7 | La entrada será recibida por **STDIN** 8 | 9 | La primera tiene 4 enteros separados por un espacio, el número de nodos **N**, el número de calles **E** que conecta cada nodo, el nodo inicial **a**(la casa de Juanito) y el nodo que representa la oficina **b**. 10 | 11 | Después hay **E** lineas correspondientes a cada calle, estas lineas tienen 3 enteros separados por un espacio **x**, **y**, **Z**, el numero que identifica a los 2 nodos que conecta la calle y la cantidad de tráfico donde entre más grande el número peor está el tráfico. 12 | 13 | ### Output 14 | 15 | Imprime a salida estandar **STDOUT** los nodos que tiene que recorrer. 16 | 17 | ### Ejemplos 18 | 19 | ![grafo](grafo.png) 20 | 21 | #### Entrada 22 | ``` 23 | 11 21 5 10 24 | 0 1 4 25 | 0 5 7 26 | 0 6 11 27 | 1 2 1 28 | 1 3 12 29 | 1 6 5 30 | 2 3 8 31 | 2 6 5 32 | 2 10 15 33 | 3 4 6 34 | 3 6 9 35 | 3 8 9 36 | 3 9 13 37 | 3 10 10 38 | 4 5 2 39 | 4 6 3 40 | 4 7 9 41 | 4 9 7 42 | 7 8 14 43 | 7 9 6 44 | 8 10 6 45 | ``` 46 | #### Salida 47 | 48 | ``` 49 | 5 4 3 10 50 | ``` 51 | 52 | ### Detalles 53 | Utiliza Dijkstra para calcular el camino más corto. -------------------------------------------------------------------------------- /ene-jun-2019/Mario Manzano/Practicas/Practica_4.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | 3 | public class Practica_4 { 4 | public static void main(String[] args) { 5 | Scanner s = new Scanner(System.in); 6 | int n = s.nextInt(); 7 | String ln = s.nextLine(); 8 | String[] arr = ln.split(" "); 9 | print(merge(arr)); 10 | } 11 | 12 | private static String[] merge(String[] arr) { 13 | if(arr.length>1) { 14 | int x = arr.length/2; 15 | String[] a = Arrays.copyOfRange(arr, 0, x); 16 | String[] b = Arrays.copyOfRange(arr, x, arr.length); 17 | return sort(merge(a), merge(b)); 18 | } 19 | return arr; 20 | } 21 | 22 | private static String[] sort(String[] a, String[] b) { 23 | String[] arr = new String[(a.length+b.length)]; 24 | int i=0, j=0, k=0; 25 | while(i= a[i].compareToIgnoreCase(b[j])) { 27 | arr[k] = a[i]; i++; 28 | } else { 29 | arr[k] = b[j]; j++; 30 | } k++; 31 | } 32 | 33 | while(i elemMasGrande){ 22 | elemMasGrande = elem; 23 | } 24 | } 25 | 26 | // Crear arreglo de conteo de 0..elemMasGrande 27 | int []arrConteo = new int[elemMasGrande+1]; 28 | 29 | // Recorrer arreglo de entrada para contar cuántos elementos hay. 30 | for(int elem : arr){ 31 | // Llevar la cuenta en el arreglo de conteo 32 | arrConteo[elem] += 1; 33 | } 34 | 35 | // Recorrer arreglo de conteo para hacer suma acumulativa. 36 | for(int i = 1; i < arrConteo.length; i++){ 37 | arrConteo[i] = arrConteo[i]+arrConteo[i-1]; 38 | } 39 | 40 | // Recorrer el arreglo principal de atrás para delante y acomodar los elementos. 41 | int []res = new int[arr.length]; 42 | for(int i = arr.length-1; i >= 0; i--){ 43 | int elemActual = arr[i]; 44 | int posFinal = arrConteo[elemActual] - 1; 45 | res[posFinal] = elemActual; 46 | 47 | arrConteo[elemActual] = arrConteo[elemActual] - 1; 48 | } 49 | 50 | return res; 51 | } 52 | } -------------------------------------------------------------------------------- /ago-dic-2021/practicas/practica6/README.md: -------------------------------------------------------------------------------- 1 | ## Ejercicio Ordenando 2 | 3 | Este semestre se realizó la primera edición de las Olimpiadas Pumas. Muchos estudiantes participaron en diferentes competencias deportivas y consiguieron muchas medallas. Pero todavía no se sabe quién fue el que quedó en primer lugar. 4 | 5 | Para esto hay que considerar quién tiene más medallas de Oro, si algunos participantes tienen la misma cantidad se determina por el número de medallas de Plata, y si también coinciden ahí se desempata por medallas de Bronce. 6 | 7 | Si tienen el mismo número de medallas de oro, plata y bronce puedes ordenarlos por orden alfabético. 8 | 9 | Dada una lista con los concursantes y cuántas medallas consiguieron, imprime la lista ordenada con las reglas de arriba. 10 | 11 | 12 | ### Input 13 | 14 | La entrada será recibida por **STDIN** 15 | 16 | La primera linea tiene un entero **n**, donde **150){ 14 | System.out.println("Numero de Pokemon NO VALIDO"); 15 | } 16 | int [] POKEMON = new int [pokemon]; 17 | System.out.println("Poder de Cada Pokemon"); 18 | 19 | for (int i = 0; i < POKEMON.length; i++) { 20 | poder=sc.nextInt(); 21 | if(poder>2000){ 22 | System.out.println("Poder No Existente"); 23 | } 24 | POKEMON[i]=poder; 25 | } 26 | 27 | int actual=0, j=0; 28 | 29 | for (int i = 1; i < POKEMON.length; i++) { 30 | actual=POKEMON[i]; 31 | j=i-1; 32 | while ((j >= 0) && (actual > POKEMON[j])){ 33 | POKEMON[j + 1] = POKEMON[j]; 34 | j--; 35 | } 36 | 37 | POKEMON[j + 1] = actual; 38 | 39 | } 40 | System.out.print("PODERES DE POKEMON ORDENADOS: "); 41 | printpokemon(POKEMON); 42 | } 43 | 44 | public static void printpokemon (int [] POKEMON){ 45 | for (int i = 0; i 1) { 9 | int mitad = arr.length / 2; 10 | String[] a = Arrays.copyOfRange(arr, 0, mitad); 11 | String[] b = Arrays.copyOfRange(arr, mitad, arr.length); 12 | return sort(merge(a), merge(b)); 13 | } 14 | 15 | return arr; 16 | } 17 | 18 | public static String[] sort(String[] a, String[] b) { 19 | String[] arr = new String[(a.length + b.length)]; 20 | int i = 0, j = 0, k = 0; 21 | 22 | while (i < a.length && j < b.length) { 23 | if (a[i].compareTo(b[j]) <= 0) { 24 | arr[k] = a[i]; 25 | i++; 26 | } else { 27 | arr[k] = b[j]; 28 | j++; 29 | } 30 | 31 | k++; 32 | } 33 | 34 | while (i < a.length) { 35 | arr[k] = a[i]; 36 | i++; 37 | k++; 38 | } 39 | 40 | while (j < b.length) { 41 | arr[k] = b[j]; 42 | j++; 43 | k++; 44 | } 45 | 46 | return arr; 47 | } 48 | 49 | 50 | 51 | public static void main(String[] args) { 52 | Scanner s = new Scanner(System.in); 53 | 54 | 55 | String pderichi = s.nextLine(); 56 | 57 | String[] richardo = pderichi.split(" "); 58 | 59 | System.out.println(""); 60 | 61 | System.out.println(Arrays.toString(merge(richardo))); 62 | 63 | 64 | 65 | } 66 | } 67 | -------------------------------------------------------------------------------- /ago-dic-2018/Pérez Sánchez José Jahir/Practica 3/Dinosaurios.java: -------------------------------------------------------------------------------- 1 | package algoritmos; 2 | import java.util.Scanner; 3 | public class Dinosaurios { 4 | public static void main(String[] args) { 5 | Scanner sc = new Scanner(System.in); 6 | //Variables 7 | int num_dino=0; 8 | String name_dino=""; 9 | //Tamaño del arreglo 10 | System.out.println("¿Cuantos Dinosaurios son?"); 11 | num_dino=sc.nextInt(); 12 | String[] dinosaurio=new String[num_dino+1]; 13 | //Nombre de los dinos 14 | System.out.println("¿Nombre de los Dinosaurios"); 15 | for (int i = 0; i < dinosaurio.length; i++) { 16 | name_dino=sc.nextLine(); 17 | dinosaurio[i]=name_dino; 18 | } 19 | //Mostrar lo dinos como entrada 20 | for (int i = 0; i < dinosaurio.length; i++) { 21 | System.out.print(dinosaurio[i]+"\t"); 22 | } 23 | 24 | //implementar algoritmo 25 | for (int i = 0; i < dinosaurio.length; i++) { 26 | int idxMin=1; 27 | int j=i; 28 | while(j< dinosaurio.length){ 29 | if(dinosaurio[j].length()>dinosaurio[idxMin].length()){ 30 | idxMin=j; 31 | } 32 | j++; 33 | } 34 | String temp=dinosaurio[i]; 35 | dinosaurio[i]=dinosaurio[idxMin]; 36 | dinosaurio[idxMin]=temp; 37 | } 38 | //Mostrar dinos como salida 39 | System.out.println("\n"); 40 | for (int i = 0; i < dinosaurio.length; i++) { 41 | System.out.print(dinosaurio[i]+"\t"); 42 | } 43 | } 44 | 45 | } 46 | -------------------------------------------------------------------------------- /ago-dic-2018/slides/basic/basic.slide: -------------------------------------------------------------------------------- 1 | Algoritmos Básicos 2 | Algoritmos de Ordenamiento y Búsqueda 3 | 24 Aug 2018 4 | Tags: 2018, theory 5 | 6 | Santiago Chio 7 | Developer, Sistemas UAdeC 8 | schio@uadec.edu.mx 9 | http://schiob.com 10 | @schiob 11 | 12 | * Insertion Sort 13 | 14 | .image insertion_sort.png 15 | 16 | * 17 | 18 | .code insertion.go /start insertionSort/,/end insertionSort/ 19 | .play insertion.go /start main/,/end main/ 20 | 21 | * Cómo demostramos que éste algoritmo es correcto? 22 | 23 | .image https://media.giphy.com/media/WUGNg3FuhiywU/giphy.gif _ 600 24 | 25 | * Ciclo invariante 26 | 27 | Algún predicado o condición que se mantiene en cada iteración de un ciclo. 28 | 29 | Propiedades: 30 | 31 | - Inicialización: Es verdadera antes de la primera iteración. 32 | - Mantenimiento: Es verdadera despues de cada iteración del ciclo y se mantiene verdadera antes de la siguiente iteración. 33 | - Terminación: Cuando finaliza el ciclo, la invariante aporta una propiedad que indica que el algoritmo es correcto. 34 | 35 | * Viendo estas propiedades en insertion Sort 36 | El sub-arreglo `arr[1:j-1]` consiste en los elementos originales de `arr[1:j-1]` pero en orden. 37 | 38 | - Inicialización: Cuando j = 2, el subarreglo `arr[1:1]` es de un elemento, por lo tanto está ordenado 39 | - Mantenimiento: El algoritmo mueve `arr[j-1]`, `arr[j-2]`, `arr[j-3]`, ... una posición a la derecha hasta que encuentra el lugar de `arr[j]`, en ese punto lo inserta. Al final de la iteración el subarreglo `arr[1:j]` tiene los elementos originales pero ordenados. 40 | - Terminación: Al final como `j-1` es el último elemento del arreglo, podemos determinar que todo el arreglo está ordenado y por lo tanto el algoritmo es correcto. 41 | -------------------------------------------------------------------------------- /ago-dic-2021/Juan Antonio Cruz Perez/practica 2/LinkedList.java: -------------------------------------------------------------------------------- 1 | 2 | package practicas; 3 | 4 | 5 | public class LinkedList { 6 | public Element head; 7 | public int count,valorF,valorI; 8 | LinkedList(){ 9 | head = null; 10 | 11 | } 12 | 13 | public void preppend(int dato){ 14 | Element tmp; 15 | tmp = new Element(); 16 | tmp.datum = dato; 17 | tmp.next = head; 18 | head = tmp; 19 | 20 | 21 | } 22 | 23 | public void append(int dato){ 24 | Element tmp; 25 | tmp = new Element(); 26 | tmp.datum = dato; 27 | tmp.next = null; 28 | 29 | if(head == null){ 30 | head = tmp; 31 | 32 | } 33 | else{ 34 | Element aux = head; 35 | while (aux.next != null){ 36 | aux = aux.next; 37 | } 38 | aux.next = tmp; 39 | 40 | } 41 | 42 | } 43 | 44 | public void imprimir(){ 45 | Element tmp; 46 | tmp = head; 47 | while (tmp!=null){ 48 | System.out.println(tmp.datum); 49 | tmp = tmp.next; 50 | } 51 | 52 | } 53 | 54 | public void eliminaDato(int datoAbuscar){ 55 | Element aux = head; 56 | while(aux.next != null){ 57 | while (aux.next.datum == datoAbuscar && aux.next.next != null){ 58 | aux.next = aux.next.next; 59 | } 60 | if(aux.next.next == null && aux.next.datum == datoAbuscar){ 61 | aux.next = null; 62 | break; 63 | } 64 | if (datoAbuscar == head.datum){ 65 | head = head.next; 66 | } 67 | aux = aux.next; 68 | } 69 | } 70 | 71 | public void quitaInPares(){ 72 | Element tmp; 73 | tmp = head; 74 | while (tmp!=null){ 75 | if(tmp.datum%2 != 0) 76 | eliminaDato(tmp.datum); 77 | tmp = tmp.next; 78 | } 79 | 80 | } 81 | 82 | 83 | } 84 | -------------------------------------------------------------------------------- /ago-dic-2018/Guadalupe Alejandro Pérez Camacho/practica_3/ListaDinos.java: -------------------------------------------------------------------------------- 1 | /* 2 | * To change this license header, choose License Headers in Project Properties. 3 | * To change this template file, choose Tools | Templates 4 | * and open the template in the editor. 5 | */ 6 | package javaapplication5; 7 | import java.util.*; 8 | /** 9 | * 10 | * @author Acer 11 | */ 12 | public class ListaDinos { 13 | public static void main(String[]main){ 14 | int j=0,c=0; 15 | Scanner s=new Scanner(System.in); 16 | Dinos[] d=new Dinos[1000]; 17 | String lista; 18 | System.out.println("Escibe los nombres de los dinosaurios separadolos con un Espacio"); 19 | lista=s.nextLine(); 20 | for (int i = 0; i <=lista.length(); i++) { 21 | j=i; 22 | String t=""; 23 | while (j!=lista.length()&&lista.charAt(j)!=' ') { 24 | t+=lista.charAt(j); 25 | j++; 26 | } 27 | d[c]=new Dinos(t); 28 | t=""; 29 | c++; 30 | i=j; 31 | } 32 | j=1; 33 | c=0; 34 | while (d[j]!=null) { 35 | j++; 36 | } 37 | int min=0; 38 | for (int i = 0; i < j; i++) { 39 | for (int k = 1; k < j; k++) { 40 | if (d[k-1].getTamañoNombre()>d[k].getTamañoNombre()) { 41 | String t=d[k-1].getNombre(); 42 | d[k-1].setNombre(d[k].getNombre()); 43 | d[k].setNombre(t); 44 | } 45 | } 46 | } 47 | j=0; 48 | while (d[j]!=null) { 49 | System.out.print(d[j].getNombre()+" "); 50 | j++; 51 | } 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /ago-dic-2018/slides/divide-conquer/divide.slide: -------------------------------------------------------------------------------- 1 | Divide and conquer 2 | Algoritmos de Ordenamiento y Búsqueda 3 | 11 Aug 2018 4 | Tags: 2018, theory 5 | 6 | Santiago Chio 7 | Developer, Sistemas UAdeC 8 | schio@uadec.edu.mx 9 | http://schiob.com 10 | @schiob 11 | 12 | * Recursion 13 | 14 | Muchos algoritmos son recursivos en la estructura. Se llaman a si mismo una o más veces para lidiar con subproblemas relacionados. 15 | 16 | Estos algoritmos hacen una práctica de divide y vencerás. 17 | 18 | Rompen el problema en subproblemas que son similares al original pero más pequeños, se solucionan los subproblemas recursivamente, y luego se combinan esas soluciones para solucionar el problema original. 19 | 20 | * 21 | 22 | - Dividir el problema en subproblema que son pequeñas instancias del problema original. 23 | 24 | - Resuelve los subproblemas de forma recursiva. Si son lo sificientemente pequeños soluciónalo de forma convencional. 25 | 26 | - Combina las soluciones del subproblema en la solución del problema original. 27 | 28 | * Merge Sort 29 | 30 | - Dividir la secuencia de *n* elementos en 2 subsecuencias de *n/2*. 31 | 32 | - Ordena las 2 subsecuencias de forma recursiva usando merge sort. 33 | 34 | - Combina las 2 subsecuencias ordenadas para producir la secuencia ordenada. 35 | 36 | La recursion se detiene cuando la secuencia a ordenar es de 1 elemento. 37 | 38 | * 39 | 40 | .image https://idea-instructions.com/merge-sort.png _ 900 41 | 42 | * 43 | .code merge.go /start merge/,/end merge/ 44 | 45 | * 46 | .code merge.go /start mergeSort/,/end mergeSort/ 47 | .play merge.go /start main/,/end main/ 48 | 49 | * 50 | .image https://i.redd.it/ke79d99ynaz11.png 600 _ 51 | 52 | * 53 | .image https://i.redd.it/r875l55fzhz11.png 600 _ 54 | -------------------------------------------------------------------------------- /ene-jun-2019/practicas/practica_8/README.md: -------------------------------------------------------------------------------- 1 | # Práctica 8 - Otro grafo pero pesado 2 | 3 | Este fin de semana los alumnos de la Facultad de Sistemas tuvieron un Rally en un evento especial. Tenían que ir a diferentes estaciones y hacer algún ejercicio para obtener puntos. El problema es que tienen un tiempo límite y quieren saber cuánto tiempo les puede llegar a tomar hacer el recorrido hasta la estación que les falta. 4 | 5 | Por suerte desarrollaste un programa que hace específicamente eso. 6 | 7 | Dados los nodos y aristas (con peso) de un grafo, el nodo inicial y el nodo destino. Imprimir un camino y el tiempo que les va a tomar llegar. Este camino no tiene que ser el más óptimo. 8 | 9 | ### Input 10 | 11 | La entrada será recibida por **STDIN** 12 | 13 | La primera tiene 4 enteros separados por un espacio, el número de estaciones **N**, el número de caminos **E** que conecta las estaciones, la estación inicial **a** y la estación destino **b**. 14 | 15 | Después hay **E** lineas correspondientes a cada camino, estas lineas tienen 3 enteros separados por un espacio **x**, **y**, **Z**, el numero que identifica a las 2 estaciones que conecta el puente y la cantidad de segundos que se tarda en llegar de una a la otra. 16 | 17 | ### Output 18 | 19 | Imprime a salida estandar **STDOUT** las estaciones que tienen que recorrer y el total de segundos. 20 | 21 | ### Ejemplos 22 | 23 | ![grafo](grafo.png) 24 | 25 | #### Entrada 26 | ``` 27 | 9 13 3 6 28 | 0 1 7 29 | 0 2 19 30 | 0 3 16 31 | 2 3 11 32 | 2 8 20 33 | 2 4 13 34 | 2 5 30 35 | 3 4 9 36 | 4 5 25 37 | 4 7 23 38 | 5 7 16 39 | 5 6 14 40 | 7 6 9 41 | ``` 42 | #### Salida 43 | 44 | ``` 45 | 3 4 5 6 Total:48 46 | ``` 47 | 48 | ### Detalles 49 | Pueden haber varias respuestas correctas, usen BFS o DFS. -------------------------------------------------------------------------------- /ene-jun-2021/material/algoritmos/suma.java: -------------------------------------------------------------------------------- 1 | import java.util.Arrays; 2 | 3 | public class suma { 4 | public static void main(String args[]) { 5 | int []arr = {4, 6, 7, 4, 5, 2}; 6 | // Suma{4, 6, 7, 4, 5, 2}; 7 | // 4+Suma{6, 7, 4, 5, 2}; 8 | // Suma{4} + Suma{6, 7}+Suma{4, 5, 2}; 9 | 10 | int total = sumar(arr); 11 | int total2 = sumarRecur(arr); 12 | int total3 = sumarRecur2(arr); 13 | 14 | System.out.println(total); 15 | System.out.println(total2); 16 | System.out.println(total3); 17 | } 18 | 19 | public static int sumar(int[] arr){ 20 | int total = 0; 21 | 22 | for(int elem : arr){ 23 | total += elem; 24 | } 25 | return total; 26 | } 27 | 28 | public static int sumarRecur(int[] arr){ 29 | if(arr.length == 1){ 30 | return arr[0]; 31 | } 32 | 33 | int middle = arr.length / 2; 34 | int elemExtra = 0; 35 | if (arr.length % 2 != 0){ 36 | elemExtra = 1; 37 | } 38 | int []arrIzq = new int[middle]; 39 | int []arrDer = new int[middle + elemExtra]; 40 | 41 | for(int i = 0 ; i < middle ; i++){ 42 | arrIzq[i] = arr[i]; 43 | } 44 | for(int i = middle; i < arr.length; i++){ 45 | arrDer[i-middle] = arr[i]; 46 | } 47 | 48 | return sumarRecur(arrIzq) + sumarRecur(arrDer); 49 | } 50 | 51 | public static int sumarRecur2(int[] arr){ 52 | if(arr.length == 1){ 53 | return arr[0]; 54 | } 55 | 56 | int[] subArr = Arrays.copyOfRange(arr, 1, arr.length); 57 | return arr[0] + sumarRecur(subArr); 58 | } 59 | } 60 | -------------------------------------------------------------------------------- /ene-jun-2020/practicas/practica9/README.md: -------------------------------------------------------------------------------- 1 | # Práctica9 - Ejercicio para trabajar el uso de grafos 2 | 3 | Formen equipos y continuen con el trabajo, el objetivo es resolver el siguiente ejercicio: 4 | 5 | ## El camino más corto a su corazón 6 | María quiere conocer a Juan, su amor platónico desde que entró a la facultad de Sistemas. Pero para hablar con él quiere que alguien que ya lo conozca los presente. 7 | 8 | Con toda la información de quién conoce a quién representada en un grafo ayuda a María a mostrarle el camino más corto de personas con las que tiene que hablar para que conozca a Juan. 9 | 10 | ### Entrada 11 | La entrada es un grafo. 12 | 13 | La primera linea tiene 3 enteros separados por un espacio, **N** el número de personas (nodos) y **E** el número de conexiones entre 2 personas (aristas) y **Z**, el número identificador de Juan, nuestro destino <3. María es representada siempre como el nodo **0**. 14 | 15 | Después hay **E** lineas, una por cada arista, en cada linea hay 2 enteros separados por espacio representando los nodos que se conectan entre si en esa arista. 16 | 17 | ### Salida 18 | Imprime la lista de nodos que tiene que seguir María para llegar hasta el nodo **Z** de la forma más eficiente. 19 | 20 | ### Ejemplo 21 | ![grafo](grafo.png) 22 | 23 | #### Entrada 24 | ``` 25 | 16 20 13 26 | 0 1 27 | 0 2 28 | 0 3 29 | 0 7 30 | 0 8 31 | 1 15 32 | 2 4 33 | 2 5 34 | 2 6 35 | 3 7 36 | 3 9 37 | 3 10 38 | 3 11 39 | 4 13 40 | 4 5 41 | 5 14 42 | 6 9 43 | 9 11 44 | 9 14 45 | 9 12 46 | ``` 47 | #### Salida 48 | 49 | ``` 50 | 0 2 4 13 51 | ``` 52 | 53 | ### Tips 54 | Usa BFS para recorrer el grafo y con él generar la lista de nodos que forman el camino más corto. 55 | 56 | Puede haber varios caminos de la misma longitud, en ese caso cualquiera es válido. 57 | -------------------------------------------------------------------------------- /ene-jun-2019/Juan Arnoldo Chavez Munoz/practica_2/Practica_2.java: -------------------------------------------------------------------------------- 1 | 2 | package algoritmosorden; 3 | import java.util.Arrays; 4 | import java.util.Scanner; 5 | 6 | public class Practica_2 { 7 | public static void main(String[] args) { 8 | 9 | int valor=0, temp=0; 10 | Scanner s= new Scanner(System.in); 11 | System.out.println("Ingrese el numero de hamburguesas entre 1-50 "); 12 | valor=s.nextInt(); 13 | while(valor > 50 || valor <1) { 14 | System.out.println("Carajo, que escribas un numero entre 1-50!!"); 15 | valor=s.nextInt(); 16 | } 17 | int [] numham= new int [valor]; 18 | 19 | System.out.println("Ingrese las calificaciones de las hamburguesas (0-100): ");//Se ingresan los numeros al arreglo. 20 | 21 | for (int i = 0; i < valor; i++) 22 | { 23 | 24 | numham[i] = s.nextInt(); 25 | while (numham[i]>100 ||numham[i]<0) { //aquí se usa para poner los parametros de medición. 26 | System.out.println("La calificación debe estar entre 0-100"); 27 | numham[i] = s.nextInt(); 28 | } 29 | } 30 | 31 | for (int i = 1; i -1 && numham[j] -1 && numdehamburguesas[j] < temp ; j--) 42 | { 43 | numdehamburguesas[j+1] = numdehamburguesas[j]; 44 | } 45 | 46 | numdehamburguesas[j+1] = temp; 47 | } 48 | 49 | System.out.println("Estas son las calificaciones ordenadas de mayor a menor: "); 50 | 51 | for (int i = 0; i < numdehamburguesas.length; i++) //Se imprimen 52 | { 53 | System.out.println(numdehamburguesas[i]); 54 | } 55 | } 56 | } 57 | -------------------------------------------------------------------------------- /ago-dic-2022/practicas/practica8/README.md: -------------------------------------------------------------------------------- 1 | # Práctica 8 - Ejercicio para trabajar el uso de grafos 2 | 3 | Juan es el encargado de Salud en la Universidad y está planeando el regreso a clases presenciales, el tema es que tenemos que tener mucho cuidado con los contagios. Por lo mismo Juan te pide que crees un programa para identificar cuáles personas son las que tienen que ponerse en cuarentena cuando alguien salga positivo. 4 | 5 | Afortunadamente tienes una base de datos con los alumnos de la universidad y con las personas que tuvieron contacto la semana pasada. Junto con una lista de las personas que salieron positivas. 6 | 7 | Procesa los datos y muestra una lista de las personas que estuvieron en contacto directo con los que salieron positivos. 8 | 9 | ## Entrada 10 | La entrada es un grafo. 11 | 12 | La primera linea tiene 3 enteros separados por un espacio, **N** el número de personas (nodos) y **E** el número de conexiones entre 2 personas (aristas) y **Z**, el número positivos. Todas las personas se identifican desde **0** hasta **N-1** 13 | 14 | Después hay **E** lineas, una por cada arista, en cada linea hay 2 enteros separados por espacio representando los nodos que se conectan entre si en esa arista. Estas son 2 personas que tuvieron contacto directo. 15 | 16 | Luego hay **Z** números separados por espacio, las personas que se detectaron como positivas. 17 | 18 | ## Salida 19 | Imprime la lista de nodos (personas) que tuvieron contacto directo con una persona positiva y tienen que entrar en cuarentena. 20 | 21 | ## Ejemplo 22 | ![grafo](grafo.png) 23 | 24 | ### Entrada 25 | ``` 26 | 16 20 3 27 | 0 1 28 | 0 2 29 | 0 3 30 | 0 7 31 | 0 8 32 | 1 15 33 | 2 4 34 | 2 5 35 | 2 6 36 | 3 7 37 | 3 9 38 | 3 10 39 | 3 11 40 | 4 13 41 | 4 5 42 | 5 14 43 | 6 9 44 | 9 11 45 | 9 14 46 | 9 12 47 | 5 6 15 48 | ``` 49 | ### Salida 50 | 51 | ``` 52 | 4 2 14 9 1 53 | ``` 54 | 55 | -------------------------------------------------------------------------------- /ene-jun-2019/practicas/practica_7/README.md: -------------------------------------------------------------------------------- 1 | # Práctica 7 - Mi primer grafo 2 | 3 | Recuerdas a Susana? Si, la misma Susana que te pidió ordenar su inventario de Minecraft. Bueno, solicita tu ayuda otra vez porque quedó muy satisfecha con tu último trabajo. 4 | 5 | En su mundo de Minecraft construyó su base con una temática de archipiélago, así que tiene varias islas conectadas por puentes. La isla con la granja de aldeanos, la isla con los cultivos, la isla con su casa, la isla con la trampa de monstruos, la sorprendente isla de pollos, entre muchas otras. 6 | 7 | El problema es que ya construyó muuuuchas islas después de 5 años jugando en el mismo mapa, y suele olvidar dónde quedan ciertas islas. Así que te pide que hagas un programa para que le indique el camino para llegar a la isla deseada. 8 | 9 | Puede ser cualquier camino :) 10 | 11 | ### Input 12 | 13 | La entrada será recibida por **STDIN** 14 | 15 | La primera tiene 3 enteros separados por un espacio, el número de islas **N**, el número de puentes **E**, el la isla a la que quiere ir Susana **b**. 16 | 17 | Después hay **E** lineas correspondientes a cada puente, estas lineas tienen 2 enteros separados por un espacio **x** **y** el numero que identifica a las 2 islas que conecta el puente. 18 | 19 | Susana siempre empieza en la isla **0** que es su casa. 20 | 21 | ### Output 22 | 23 | Imprime a salida estandar **STDOUT** las islas que tiene que atravezar Susana para llegar a la isla deseada. 24 | 25 | ### Ejemplos 26 | 27 | ![grafo](grafo.png) 28 | 29 | #### Entrada 30 | ``` 31 | 16 20 5 32 | 0 1 33 | 0 2 34 | 0 3 35 | 0 7 36 | 0 8 37 | 1 15 38 | 2 4 39 | 2 5 40 | 2 6 41 | 3 7 42 | 3 9 43 | 3 10 44 | 3 11 45 | 4 13 46 | 4 5 47 | 5 14 48 | 6 9 49 | 9 11 50 | 9 14 51 | 9 12 52 | ``` 53 | #### Salida 54 | 55 | ``` 56 | 0 2 5 57 | ``` 58 | 59 | ### Detalles 60 | Pueden haber varias respuestas correctas, usen BFS o DFS. -------------------------------------------------------------------------------- /ago-dic-2018/Guadalupe Alejandro Pérez Camacho/practica_1/JavaApplication5.java: -------------------------------------------------------------------------------- 1 | package javaapplication5; 2 | import javax.swing.*; 3 | 4 | public class JavaApplication5 { 5 | public static void main(String[] args) { 6 | int n=Integer.parseInt(JOptionPane.showInputDialog(null,"N° de registros a ingresar")); 7 | Alumno a[]=new Alumno[n]; 8 | int q=n; 9 | String s=""; 10 | String ss=""; 11 | String Mayor_nombre=""; 12 | int Mayor_contador=0; 13 | for (int i = 0; i < n; i++) { 14 | boolean flag=false; 15 | int c=0; 16 | s=JOptionPane.showInputDialog("Quedan "+q+" registros por ingresar ", "Nombre"); 17 | while (a[c]!=null&&!a[c].getNombre().equalsIgnoreCase(s)) { 18 | c++; 19 | } 20 | if (a[c]!=null&&a[c].getNombre().equalsIgnoreCase(s)) { 21 | a[c].setContador(a[c].getContador()+1); 22 | flag=true; 23 | } 24 | if (flag==false) { 25 | a[c]=new Alumno(s); 26 | } 27 | q--; 28 | } 29 | int c=0; 30 | int b=0; 31 | Mayor_nombre=a[c].getNombre(); 32 | Mayor_contador=a[c].getContador(); 33 | c++; 34 | while (a[c]!=null) { 35 | if (a[c].getContador()>Mayor_contador) { 36 | Mayor_nombre=a[c].getNombre(); 37 | Mayor_contador=a[c].getContador(); 38 | } 39 | if (a[c].getContador()==Mayor_contador&&!a[c].getNombre().equalsIgnoreCase(Mayor_nombre)) { 40 | ss+=a[c].getNombre()+"\n"; 41 | } 42 | c++; 43 | } 44 | System.out.println("Nombre más repetido: "+Mayor_nombre+"\nContador: "+Mayor_contador+"\n"+"Nombres igualmente repetidos: \n"+ss); 45 | 46 | } 47 | 48 | } 49 | -------------------------------------------------------------------------------- /ago-dic-2018/Pérez Sánchez José Jahir/Practica 4/prueba.java: -------------------------------------------------------------------------------- 1 | 2 | package algoritmos; 3 | 4 | import java.util.Scanner; 5 | 6 | public class prueba { 7 | public static void Ordena(Libro arreglo[]){ 8 | Libro [] x = new Libro[arreglo.length]; 9 | mergeSort(arreglo, x, 0, arreglo.length-1); 10 | } 11 | 12 | private static void mergeSort(Libro[] a, Libro[] x,int izq, int der){ 13 | if(izq < der){ 14 | int centro = (izq + der)/2; 15 | mergeSort(a, x, izq, centro); 16 | mergeSort(a, x, centro+1, der); 17 | merge(a, x, izq, centro+1, der); 18 | } 19 | } 20 | private static void merge(Libro [] a, Libro [] x, int izq, int der, int p){ 21 | int h = der-1; 22 | int j = izq; 23 | int w = izq; 24 | 25 | while(izq <= h && der <= p){ 26 | if(a[izq].getPages() < a[der].getPages()){ 27 | x[j++] = a[izq++]; 28 | }else{ 29 | x[j++] = a[der++]; 30 | } 31 | } 32 | while(izq <= h){ 33 | x[j++] = a[izq++]; 34 | } 35 | while(der <= p){ 36 | x[j++] = a[der++]; 37 | } 38 | for(j = w; j <= p; j++){ 39 | a[j] = x[j]; 40 | } 41 | } 42 | public static void main(String[] args) { 43 | Scanner sc = new Scanner(System.in); 44 | int n=Integer.parseInt(sc.nextLine()); 45 | Libro[] LL=new Libro[n]; 46 | for (int i = 0; i < n; i++) { 47 | String name; 48 | int pages; 49 | String [] line=sc.nextLine().split(" "); 50 | //+Integer.parseInt(line[2]/60.0 51 | name=line[0]; 52 | pages=Integer.parseInt(line[1]); 53 | //Libro L=new Libro(name,pages); 54 | LL[i]=new Libro(name,pages); 55 | } 56 | Ordena(LL); 57 | for (int i = 0; i < n; i++) { 58 | System.out.print(LL[i].getName()+"\t"); 59 | } 60 | } 61 | 62 | } 63 | -------------------------------------------------------------------------------- /ago-dic-2018/practicas/practica_8/README.md: -------------------------------------------------------------------------------- 1 | # Práctica 8 - Buscando, pero ahora buscamos ciclos 2 | 3 | El granjero Bob ya vendió sus vacas, resulta que eran demasiado problemáticas. Ahora solo tiene Truchas, muchas, muchas truchas de diferentes edades en varios estanques. Esos estanques están conectados unos con otros con pequeños riachuelos, donde las truchas más pequeñas en los estanques chicos pueden viajar a estanques más grandes cuando crecen, pero esos riachuelos son de un solo sentido, para que las truchas grandes no puedan ir a los estanques pequeños y comerse a sus hermanos pequeños :( . 4 | Bob tiene **N** estanques en su granja identificados con números desde el **0** a **N-1**. Estos estanques están conectados por **E** riachuelos. 5 | 6 | Asegúrate de que no haya ninguna forma de que en un camino las truchas puedan regresar a un estanque en el que estaban antes. 7 | 8 | ### Input 9 | 10 | La entrada será recibida por **STDIN** 11 | 12 | Consiste en varias lineas. La primera tiene 2 enteros separados por un espacio, el número de estanques **N** y el número de riachuelos **E**. 13 | 14 | Después hay **E** lineas correspondientes a cada riachuelo, estas lineas tienen 2 enteros separados por un espacio **x** **y** el numero que identifica a los estanques que conecta el riachuelo, donde el estanque **x** es de donde salen las truchas y el **y** a donde llegan. 15 | 16 | ### Output 17 | 18 | Imprime a salida estandar **STDOUT** *"todo bien"* si no encontraste ciclos y de lo contrario imprime *"hay problemas Bob"*. 19 | 20 | ### Ejemplos 21 | 22 | #### Entrada 23 | ``` 24 | 5 6 25 | 0 2 26 | 0 1 27 | 0 3 28 | 3 4 29 | 1 4 30 | 2 4 31 | ``` 32 | #### Salida 33 | 34 | ``` 35 | todo bien 36 | ``` 37 | 38 | #### Entrada 39 | ``` 40 | 5 6 41 | 0 2 42 | 0 1 43 | 0 3 44 | 3 4 45 | 4 2 46 | 2 4 47 | ``` 48 | #### Salida 49 | 50 | ``` 51 | hay problemas Bob 52 | ``` 53 | 54 | 55 | ### Detalles 56 | Usa DFS para resolverlo. 57 | --------------------------------------------------------------------------------