Skip to content

Commit 276cea6

Browse files
kontroldevkontroldev
authored
Merge pull request mouredev#6474 from eulogioep/main
#18 - java, javascript, php y typescript
2 parents a57fc7c + a858931 commit 276cea6

File tree

4 files changed

+582
-0
lines changed

4 files changed

+582
-0
lines changed

‎Roadmap/18 - CONJUNTOS/java/eulogioep.java

+96
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,96 @@
1+
import java.util.*;
2+
3+
public class eulogioep {
4+
public static void main(String[] args) {
5+
// TEORÍA: Los conjuntos en Java
6+
/*
7+
* En Java, un Set es una colección que no puede contener elementos duplicados.
8+
* Hay tres implementaciones principales de Set:
9+
* 1. HashSet - La más rápida, no mantiene orden
10+
* 2. TreeSet - Mantiene los elementos ordenados
11+
* 3. LinkedHashSet - Mantiene el orden de inserción
12+
*
13+
* Para este ejercicio, usaremos principalmente HashSet para las operaciones básicas
14+
* y luego mostraremos ejemplos con otros tipos para las operaciones adicionales.
15+
*/
16+
17+
// PARTE 1: OPERACIONES BÁSICAS CON CONJUNTOS
18+
System.out.println("PARTE 1: OPERACIONES BÁSICAS");
19+
20+
// Creación de un conjunto
21+
Set<String> conjunto = new HashSet<>();
22+
System.out.println("Conjunto inicial: " + conjunto);
23+
24+
// 1. Añadir un elemento al final
25+
// NOTA: En un HashSet no hay "final" como tal, ya que no mantiene orden
26+
conjunto.add("Elemento1");
27+
System.out.println("Después de añadir un elemento: " + conjunto);
28+
29+
// 2. Añadir un elemento al principio
30+
// NOTA: Como HashSet no mantiene orden, es igual que añadir al final
31+
conjunto.add("Elemento2");
32+
System.out.println("Después de añadir otro elemento: " + conjunto);
33+
34+
// 3. Añadir varios elementos en bloque al final
35+
List<String> elementosNuevos = Arrays.asList("Elemento3", "Elemento4", "Elemento5");
36+
conjunto.addAll(elementosNuevos);
37+
System.out.println("Después de añadir varios elementos: " + conjunto);
38+
39+
// 4. Añadir elementos en una posición concreta
40+
// NOTA: HashSet no permite insertar en posiciones específicas
41+
// Para demostrar esto, usaremos una LinkedList temporalmente
42+
List<String> listaOrdenada = new LinkedList<>(conjunto);
43+
listaOrdenada.addAll(2, Arrays.asList("ElementoA", "ElementoB"));
44+
conjunto = new HashSet<>(listaOrdenada);
45+
System.out.println("Después de 'insertar' en posición específica: " + conjunto);
46+
47+
// 5. Eliminar un elemento
48+
conjunto.remove("Elemento3");
49+
System.out.println("Después de eliminar 'Elemento3': " + conjunto);
50+
51+
// 6. Actualizar un elemento
52+
// NOTA: En un Set no se pueden actualizar elementos directamente
53+
// Hay que eliminar el viejo y añadir el nuevo
54+
if (conjunto.remove("Elemento4")) {
55+
conjunto.add("Elemento4Actualizado");
56+
}
57+
System.out.println("Después de actualizar 'Elemento4': " + conjunto);
58+
59+
// 7. Comprobar si un elemento está en el conjunto
60+
boolean contiene = conjunto.contains("Elemento1");
61+
System.out.println("¿Contiene 'Elemento1'? " + contiene);
62+
63+
// 8. Eliminar todo el contenido
64+
conjunto.clear();
65+
System.out.println("Después de limpiar el conjunto: " + conjunto);
66+
67+
// PARTE 2: OPERACIONES EXTRA CON CONJUNTOS
68+
System.out.println("\nPARTE 2: OPERACIONES EXTRA");
69+
70+
Set<Integer> conjunto1 = new HashSet<>(Arrays.asList(1, 2, 3, 4, 5));
71+
Set<Integer> conjunto2 = new HashSet<>(Arrays.asList(4, 5, 6, 7, 8));
72+
73+
// 1. Unión
74+
Set<Integer> union = new HashSet<>(conjunto1);
75+
union.addAll(conjunto2);
76+
System.out.println("Unión: " + union);
77+
78+
// 2. Intersección
79+
Set<Integer> interseccion = new HashSet<>(conjunto1);
80+
interseccion.retainAll(conjunto2);
81+
System.out.println("Intersección: " + interseccion);
82+
83+
// 3. Diferencia
84+
Set<Integer> diferencia = new HashSet<>(conjunto1);
85+
diferencia.removeAll(conjunto2);
86+
System.out.println("Diferencia (conjunto1 - conjunto2): " + diferencia);
87+
88+
// 4. Diferencia simétrica
89+
Set<Integer> diferenciaSimetrica = new HashSet<>(conjunto1);
90+
diferenciaSimetrica.addAll(conjunto2); // Unión
91+
Set<Integer> temp = new HashSet<>(conjunto1);
92+
temp.retainAll(conjunto2); // Intersección
93+
diferenciaSimetrica.removeAll(temp); // Unión - Intersección
94+
System.out.println("Diferencia simétrica: " + diferenciaSimetrica);
95+
}
96+
}

‎Roadmap/18 - CONJUNTOS/javascript/eulogioep.js

+113
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,113 @@
1+
// TEORÍA: Conjuntos (Sets) en JavaScript
2+
/*
3+
* Un Set en JavaScript es una estructura de datos que permite almacenar valores únicos
4+
* de cualquier tipo. A diferencia de los arrays:
5+
* - Los elementos en un Set son únicos
6+
* - No hay índices numéricos para acceder a los elementos
7+
* - El orden de los elementos se mantiene según el orden de inserción
8+
*
9+
* Los Sets son útiles cuando necesitamos asegurarnos de que no hay duplicados
10+
* y cuando el orden de los elementos no es crucial.
11+
*/
12+
13+
// Función principal que demuestra todas las operaciones
14+
function demostracionSets() {
15+
console.log("PARTE 1: OPERACIONES BÁSICAS CON SETS");
16+
17+
// Creación de un Set
18+
let conjunto = new Set();
19+
console.log("Conjunto inicial:", conjunto);
20+
21+
// 1. Añadir un elemento al final
22+
conjunto.add("Elemento1");
23+
console.log("Después de añadir un elemento:", conjunto);
24+
25+
// 2. Añadir un elemento al "principio"
26+
// NOTA: En realidad, en un Set no hay concepto de principio o final
27+
conjunto.add("Elemento2");
28+
console.log("Después de añadir otro elemento:", conjunto);
29+
30+
// 3. Añadir varios elementos en bloque
31+
const nuevosElementos = ["Elemento3", "Elemento4", "Elemento5"];
32+
nuevosElementos.forEach(elemento => conjunto.add(elemento));
33+
console.log("Después de añadir varios elementos:", conjunto);
34+
35+
// 4. Añadir elementos en una posición concreta
36+
// NOTA: Los Sets no permiten insertar en posiciones específicas
37+
// Podemos convertir a array, modificar y volver a Set
38+
let arrayTemporal = Array.from(conjunto);
39+
arrayTemporal.splice(2, 0, "ElementoA", "ElementoB");
40+
conjunto = new Set(arrayTemporal);
41+
console.log("Después de 'insertar' en posición específica:", conjunto);
42+
43+
// 5. Eliminar un elemento
44+
conjunto.delete("Elemento3");
45+
console.log("Después de eliminar 'Elemento3':", conjunto);
46+
47+
// 6. Actualizar un elemento
48+
// NOTA: No se pueden actualizar elementos directamente
49+
// Hay que eliminar el viejo y añadir el nuevo
50+
if (conjunto.delete("Elemento4")) {
51+
conjunto.add("Elemento4Actualizado");
52+
}
53+
console.log("Después de actualizar 'Elemento4':", conjunto);
54+
55+
// 7. Comprobar si un elemento está en el conjunto
56+
const contiene = conjunto.has("Elemento1");
57+
console.log("¿Contiene 'Elemento1'?", contiene);
58+
59+
// 8. Eliminar todo el contenido
60+
conjunto.clear();
61+
console.log("Después de limpiar el conjunto:", conjunto);
62+
63+
console.log("\nPARTE 2: OPERACIONES EXTRA CON SETS");
64+
65+
// Creamos dos conjuntos para las operaciones
66+
const conjunto1 = new Set([1, 2, 3, 4, 5]);
67+
const conjunto2 = new Set([4, 5, 6, 7, 8]);
68+
69+
// 1. Unión
70+
const union = new Set([...conjunto1, ...conjunto2]);
71+
console.log("Unión:", union);
72+
73+
// 2. Intersección
74+
const interseccion = new Set(
75+
[...conjunto1].filter(x => conjunto2.has(x))
76+
);
77+
console.log("Intersección:", interseccion);
78+
79+
// 3. Diferencia
80+
const diferencia = new Set(
81+
[...conjunto1].filter(x => !conjunto2.has(x))
82+
);
83+
console.log("Diferencia (conjunto1 - conjunto2):", diferencia);
84+
85+
// 4. Diferencia simétrica
86+
const diferenciaSimetrica = new Set(
87+
[...conjunto1].filter(x => !conjunto2.has(x))
88+
.concat([...conjunto2].filter(x => !conjunto1.has(x)))
89+
);
90+
console.log("Diferencia simétrica:", diferenciaSimetrica);
91+
}
92+
93+
// Funciones auxiliares útiles para trabajar con Sets
94+
const utilidadesSets = {
95+
// Unión de dos sets
96+
union: (setA, setB) => new Set([...setA, ...setB]),
97+
98+
// Intersección de dos sets
99+
interseccion: (setA, setB) =>
100+
new Set([...setA].filter(x => setB.has(x))),
101+
102+
// Diferencia de dos sets
103+
diferencia: (setA, setB) =>
104+
new Set([...setA].filter(x => !setB.has(x))),
105+
106+
// Diferencia simétrica de dos sets
107+
diferenciaSimetrica: (setA, setB) =>
108+
new Set([...setA].filter(x => !setB.has(x))
109+
.concat([...setB].filter(x => !setA.has(x))))
110+
};
111+
112+
// Ejecutar la demostración
113+
demostracionSets();

‎Roadmap/18 - CONJUNTOS/php/eulogioep.php

+182
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,182 @@
1+
<?php
2+
/**
3+
* TEORÍA: Conjuntos en PHP
4+
*
5+
* En PHP, no existe una estructura de datos específica para conjuntos como en otros lenguajes.
6+
* Sin embargo, podemos simular conjuntos usando arrays y algunas funciones específicas:
7+
*
8+
* 1. array_unique() - Para eliminar duplicados
9+
* 2. array_values() - Para reindexar arrays después de operaciones
10+
* 3. array_intersect() - Para intersección
11+
* 4. array_diff() - Para diferencia
12+
* 5. array_merge() - Para unión
13+
*
14+
* También usaremos la clase SplObjectStorage para demostrar una implementación
15+
* más orientada a objetos cuando sea necesario.
16+
*/
17+
18+
class ConjuntosEjemplo {
19+
private $conjunto;
20+
21+
public function __construct() {
22+
$this->conjunto = [];
23+
}
24+
25+
/**
26+
* Muestra el contenido actual del conjunto
27+
*/
28+
public function mostrarConjunto($mensaje = "Conjunto actual") {
29+
echo "$mensaje: [" . implode(", ", $this->conjunto) . "]\n";
30+
}
31+
32+
/**
33+
* 1. Añade un elemento al final
34+
*/
35+
public function agregarAlFinal($elemento) {
36+
$this->conjunto[] = $elemento;
37+
$this->conjunto = array_values(array_unique($this->conjunto));
38+
$this->mostrarConjunto("Después de añadir '$elemento' al final");
39+
}
40+
41+
/**
42+
* 2. Añade un elemento al principio
43+
*/
44+
public function agregarAlPrincipio($elemento) {
45+
array_unshift($this->conjunto, $elemento);
46+
$this->conjunto = array_values(array_unique($this->conjunto));
47+
$this->mostrarConjunto("Después de añadir '$elemento' al principio");
48+
}
49+
50+
/**
51+
* 3. Añade varios elementos en bloque al final
52+
*/
53+
public function agregarVariosAlFinal($elementos) {
54+
$this->conjunto = array_values(array_unique(array_merge($this->conjunto, $elementos)));
55+
$this->mostrarConjunto("Después de añadir varios elementos al final");
56+
}
57+
58+
/**
59+
* 4. Añade varios elementos en bloque en una posición concreta
60+
*/
61+
public function agregarVariosEnPosicion($elementos, $posicion) {
62+
$primera_parte = array_slice($this->conjunto, 0, $posicion);
63+
$segunda_parte = array_slice($this->conjunto, $posicion);
64+
$this->conjunto = array_values(array_unique(array_merge($primera_parte, $elementos, $segunda_parte)));
65+
$this->mostrarConjunto("Después de añadir varios elementos en posición $posicion");
66+
}
67+
68+
/**
69+
* 5. Elimina un elemento en una posición concreta
70+
*/
71+
public function eliminarEnPosicion($posicion) {
72+
if (isset($this->conjunto[$posicion])) {
73+
$elemento = $this->conjunto[$posicion];
74+
unset($this->conjunto[$posicion]);
75+
$this->conjunto = array_values($this->conjunto);
76+
$this->mostrarConjunto("Después de eliminar elemento en posición $posicion");
77+
}
78+
}
79+
80+
/**
81+
* 6. Actualiza el valor de un elemento en una posición concreta
82+
*/
83+
public function actualizarEnPosicion($posicion, $nuevoValor) {
84+
if (isset($this->conjunto[$posicion])) {
85+
$this->conjunto[$posicion] = $nuevoValor;
86+
$this->conjunto = array_values(array_unique($this->conjunto));
87+
$this->mostrarConjunto("Después de actualizar elemento en posición $posicion");
88+
}
89+
}
90+
91+
/**
92+
* 7. Comprueba si un elemento está en el conjunto
93+
*/
94+
public function contiene($elemento) {
95+
$resultado = in_array($elemento, $this->conjunto);
96+
echo "¿El conjunto contiene '$elemento'? " . ($resultado ? "Sí" : "No") . "\n";
97+
return $resultado;
98+
}
99+
100+
/**
101+
* 8. Elimina todo el contenido del conjunto
102+
*/
103+
public function limpiar() {
104+
$this->conjunto = [];
105+
$this->mostrarConjunto("Después de limpiar el conjunto");
106+
}
107+
108+
/**
109+
* Obtiene el conjunto actual
110+
*/
111+
public function obtenerConjunto() {
112+
return $this->conjunto;
113+
}
114+
}
115+
116+
/**
117+
* Clase para operaciones extra con conjuntos
118+
*/
119+
class OperacionesExtra {
120+
/**
121+
* Unión de dos conjuntos
122+
*/
123+
public static function union($conjunto1, $conjunto2) {
124+
return array_values(array_unique(array_merge($conjunto1, $conjunto2)));
125+
}
126+
127+
/**
128+
* Intersección de dos conjuntos
129+
*/
130+
public static function interseccion($conjunto1, $conjunto2) {
131+
return array_values(array_intersect($conjunto1, $conjunto2));
132+
}
133+
134+
/**
135+
* Diferencia de dos conjuntos
136+
*/
137+
public static function diferencia($conjunto1, $conjunto2) {
138+
return array_values(array_diff($conjunto1, $conjunto2));
139+
}
140+
141+
/**
142+
* Diferencia simétrica de dos conjuntos
143+
*/
144+
public static function diferenciaSimetrica($conjunto1, $conjunto2) {
145+
$diff1 = array_diff($conjunto1, $conjunto2);
146+
$diff2 = array_diff($conjunto2, $conjunto1);
147+
return array_values(array_merge($diff1, $diff2));
148+
}
149+
}
150+
151+
// Demostración de uso
152+
echo "PARTE 1: OPERACIONES BÁSICAS\n";
153+
$demo = new ConjuntosEjemplo();
154+
155+
$demo->agregarAlFinal("Elemento1");
156+
$demo->agregarAlPrincipio("Elemento2");
157+
$demo->agregarVariosAlFinal(["Elemento3", "Elemento4", "Elemento5"]);
158+
$demo->agregarVariosEnPosicion(["ElementoA", "ElementoB"], 2);
159+
$demo->eliminarEnPosicion(3);
160+
$demo->actualizarEnPosicion(1, "ElementoActualizado");
161+
$demo->contiene("Elemento1");
162+
$demo->limpiar();
163+
164+
echo "\nPARTE 2: OPERACIONES EXTRA\n";
165+
$conjunto1 = [1, 2, 3, 4, 5];
166+
$conjunto2 = [4, 5, 6, 7, 8];
167+
168+
echo "Conjunto 1: [" . implode(", ", $conjunto1) . "]\n";
169+
echo "Conjunto 2: [" . implode(", ", $conjunto2) . "]\n";
170+
171+
$union = OperacionesExtra::union($conjunto1, $conjunto2);
172+
echo "Unión: [" . implode(", ", $union) . "]\n";
173+
174+
$interseccion = OperacionesExtra::interseccion($conjunto1, $conjunto2);
175+
echo "Intersección: [" . implode(", ", $interseccion) . "]\n";
176+
177+
$diferencia = OperacionesExtra::diferencia($conjunto1, $conjunto2);
178+
echo "Diferencia (conjunto1 - conjunto2): [" . implode(", ", $diferencia) . "]\n";
179+
180+
$diferenciaSimetrica = OperacionesExtra::diferenciaSimetrica($conjunto1, $conjunto2);
181+
echo "Diferencia simétrica: [" . implode(", ", $diferenciaSimetrica) . "]\n";
182+
?>

0 commit comments

Comments
 (0)