Merge branch 'mouredev:main' into main

Author: avcenal

Roadmap/05 - VALOR Y REFERENCIA/pascal/miguelex.pas

@@ -0,0 +1,179 @@
+program miguelex;
+
+var
+  num1V, num2V, num3V, num4V: integer; // Variables para el ejemplo por valor
+  num1R, num2R, num3R, num4R: ^integer; // Variables para el ejemplo por referencia
+
+{ Funcion con paso por valor }
+
+procedure incValor(a, b: integer);
+begin
+  writeLn('El valor de a es: ', a + 1);
+  writeLn('El valor de b es: ', b + 1);
+end;
+
+procedure incReferencia(var a, b: integer);
+begin
+  a := a + 1;
+  b := b + 1;
+end;
+
+procedure byValor (a, b: integer);
+var
+  aux: integer;
+begin
+  aux := a;
+  a := b;
+  b := aux;
+  writeln ('En la funcion byValor, a = ', a, ' y b = ', b);
+end;
+
+procedure byReferencia (var a, b: integer);
+var
+  aux: integer;
+begin
+  aux := a;
+  a := b;
+  b := aux;
+  writeln ('En la funcion byReferencia, a = ', a, ' y b = ', b);
+end;
+
+{ Funcion con paso por referencia }
+
+Begin
+
+  writeln('Variables por valor');
+  writeln();
+
+  num1V := 10;
+  num2V := 20;
+
+  num3V := num1V;
+  num4V := num2V;
+
+  writeln('El valor de num1 es: ', num1V);
+  writeln('El valor de num2 es: ', num2V);
+  writeln('El valor de num3 es: ', num3V);
+  writeln('El valor de num4 es: ', num4V);
+
+  writeln('A continuación vamos a cambiar el valor de num1 y num2');
+  writeln();
+
+  num1V := 30;
+  num2V := 40;
+
+  writeln('El valor de num1 es: ', num1V);
+  writeln('El valor de num2 es: ', num2V);
+  writeln('El valor de num3 es: ', num3V);
+  writeln('El valor de num4 es: ', num4V);
+  writeln();
+
+  writeln('Variables por referencia');
+  writeln();
+  { Por referencia }
+  GetMem(num1R, SizeOf(integer));
+  GetMem(num2R, SizeOf(integer));
+  num3R := num1R;
+  num4R := num2R;
+
+  num1R^ := 10;
+  num2R^ := 20;
+
+  writeln('El valor de num1 es: ', num1R^);
+  writeln('El valor de num2 es: ', num2R^);
+  writeln('El valor de num3 es: ', num3R^);
+  writeln('El valor de num4 es: ', num4R^);
+  writeln();
+
+  writeln('A continuación vamos a cambiar el valor de num1 y num2');
+  writeln();
+  num1R^ := 30;
+  num2R^ := 40;
+
+  writeln('El valor de num1 es: ', num1R^);
+  writeln('El valor de num2 es: ', num2R^);
+  writeln('El valor de num3 es: ', num3R^);
+  writeln('El valor de num4 es: ', num4R^);
+
+  writeln('Como podemos ver, el valor de num3 y num4 cambió, ya que son referencias a las variables originales');
+  writeln();
+  FreeMem(num1R);
+  FreeMem(num2R);
+
+  { Ejemplo de funcion con paso por valor }
+
+  writeln('Ejemplo de función con paso por valor');
+  writeln();
+
+  num1V := 1;
+  num2V := 2;
+
+  writeln('Valores de num1 y num2 antes de llamar a la función incValor');
+  writeln('Num1 = ', num1V); 
+  writeln('Num2 = ', num2V);
+  writeln();
+
+  incValor(num1V, num2V);
+  writeln();
+
+  writeln('Valores de num1 y num2 después de llamar a la función incValor');
+  writeln('Num1 = ', num1V);
+  writeln('Num2 = ', num2V);
+  writeln();
+
+  writeln('Ejemplo de función con paso por valor');
+  writeln();
+  
+  num1V := 1;
+  num2V := 2;
+
+  writeln('Valores de num1 y num2 antes de llamar a la función incReferencia');
+  writeln('Num1 = ', num1V);
+  writeln('Num2 = ', num2V);
+  writeln();
+
+  incReferencia(num1V, num2V);
+
+  writeln('Valores de num1 y num2 después de llamar a la función incReferencia');
+  writeln('Num1 = ', num1V);
+  writeln('Num2 = ', num2V);
+  writeln();
+
+  { Extra }
+
+  writeln('Ejemplo de función extra con paso por valor');
+  writeln();
+
+  num1V := 5;
+  num2V := 10;
+
+  writeln('Valores de num1 y num2 antes de llamar a la función byValor');
+  writeln('Num1 = ', num1V);
+  writeln('Num2 = ', num2V);
+  writeln();
+
+  byValor(num1V, num2V);
+  writeln();
+
+  writeln('Valores de num1 y num2 después de llamar a la función byValor');
+  writeln('Num1 = ', num1V);
+  writeln('Num2 = ', num2V);
+  writeln();
+
+  writeln('Ejemplo de función extra con paso por referencia');
+  writeln();
+
+  writeln('Valores de num1 y num2 antes de llamar a la función byReferencia');
+  writeln('Num1 = ', num1V);
+  writeln('Num2 = ', num2V);
+  writeln();
+
+  byReferencia(num1V, num2V);
+  writeln();
+
+  writeln('Valores de num1 y num2 después de llamar a la función byReferencia');
+  writeln('Num1 = ', num1V);
+  writeln('Num2 = ', num2V);
+  writeln();
+
+end.

Roadmap/05 - VALOR Y REFERENCIA/python/oriaj3.py

@@ -0,0 +1,110 @@
+"""
+05 - VALOR Y REFERENCIA
+Autor de la solución: Oriaj3
+
+Teoría:
+En Python, las variables pueden ser asignadas por valor o por referencia, dependiendo del tipo de dato que almacenan.
+- Asignación por valor: Cada variable tiene su propio valor independiente. Esto sucede con tipos de datos primitivos como enteros, flotantes y cadenas.
+- Asignación por referencia: Se comparte la referencia al objeto en la memoria. Esto sucede con tipos de datos mutables como listas y diccionarios. Modificar un objeto afecta a todas las variables que hacen referencia a él.
+- Dentro de una clase, las variables de instancia se pasan por referencia, mientras que las variables de clase se pasan por valor.
+"""
+
+# EJERCICIOS 
+# Muestra ejemplos de asignación de variables "por valor" y "por referencia", según su tipo de dato.
+# Muestra ejemplos de funciones con variables que se les pasan "por valor" y "por referencia", y cómo se comportan en cada caso en el momento de ser modificadas.
+# (Entender estos conceptos es algo esencial en la gran mayoría de lenguajes)
+
+
+# Asignación de variables "por valor" y "por referencia"
+# Por valor (tipos primitivos)
+a = 5
+b = a  # a y b son independientes
+b = 10
+print(a)  # a sigue siendo 5
+print(b)  # b es 10
+
+# Por referencia (tipos compuestos)
+list_1 = [1, 2, 3]
+list_2 = list_1  # list_2 apunta al mismo objeto que list_1
+list_2.append(4)
+print(list_1)  # list_1 se ve afectada, [1, 2, 3, 4]
+print(list_2)  # list_2 es [1, 2, 3, 4]
+
+# Funciones con parámetros "por valor" y "por referencia"
+# Por valor
+def modify_value(value):
+    value = 10
+    return value
+
+# Ejemplo de uso
+a = 5
+print(modify_value(a))  # 10
+print(a)  # 5
+
+# Por referencia
+def modify_reference(list):
+    list.append(4)
+    return list
+
+# Ejemplo de uso
+list_1 = [1, 2, 3]
+print(modify_reference(list_1))  # [1, 2, 3, 4]
+print(list_1)  # [1, 2, 3, 4]
+
+
+# DIFICULTAD EXTRA (opcional):
+# Crea dos programas que reciban dos parámetros (cada uno) definidos como variables anteriormente.
+# - Cada programa recibe, en un caso, dos parámetros por valor, y en otro caso, por referencia.
+#   Estos parámetros los intercambia entre ellos en su interior, los retorna, y su retorno
+#   se asigna a dos variables diferentes a las originales. A continuación, imprime el valor de las
+#   variables originales y las nuevas, comprobando que se ha invertido su valor en las segundas.
+#   Comprueba también que se ha conservado el valor original en las primeras.
+
+# Programa 1: Intercambio de parámetros por valor
+def exchange_values(value_1, value_2):
+    tmp = value_1
+    value_1 = value_2
+    value_2 = tmp
+    return value_1, value_2
+
+# Ejemplo de uso
+original_value_1 = 'Hola'
+original_value_2 = 'Mundo'
+
+new_value_1, new_value_2 = exchange_values(original_value_1, original_value_2)
+
+print(f"Original Values: {original_value_1}, {original_value_2}")  # Original Values: Hola, Mundo
+print(f"New Values: {new_value_1}, {new_value_2}")  # New Values: Mundo, Hola
+
+# Programa 2: Intercambio de parámetros por referencia
+# En este caso, se intercambiará el primer elemento de cada lista entre sí (siendo un seudo-puntero). 
+def exchange_references(puntero_1, puntero_2):
+    puntero_1[0], puntero_2[0] = puntero_2[0], puntero_1[0]
+    return puntero_1, puntero_2
+
+# Ejemplo de uso
+original_list_1 = ['Hola']
+original_list_2 = ['Python']
+
+new_list_1, new_list_2 = exchange_references(original_list_1, original_list_2)
+
+print(f"Original Lists: [{original_list_1[0]}], [{original_list_2[0]}]")  # Original Lists: [Python], [Hola]
+print(f"New Lists: [{new_list_1[0]}], [{new_list_2[0]}]")  # New Lists: [Python], [Hola]
+
+# Programa 2: Intercambio de parámetros por referencia (con listas)
+# En este caso, se intercambiara todo el contenido de las listas entre sí.
+def exchange_references(list_1, list_2):
+    if len(list_1) != len(list_2):
+        return None
+    for i in range(len(list_1)):
+        list_1[i], list_2[i] = list_2[i], list_1[i]
+    return list_1, list_2
+
+# Ejemplo de uso
+original_list_1 = ['Lista 1 Elemento 0', 'Lista 1 Elemento 1']
+original_list_2 = ['Lista 2 Elemento 0', 'Lista 2 Elemento 1']
+
+new_list_1, new_list_2 = exchange_references(original_list_1, original_list_2)
+
+print(f"Original Lists: {original_list_1}, {original_list_2}")  # Original Lists: ['Hola', 'Mundo'], ['Python', '3.10.11']
+print(f"New Lists: {new_list_1}, {new_list_2}")  # New Lists: ['Python', '3.10.11'], ['Hola', 'Mundo']

Roadmap/05 - VALOR Y REFERENCIA/python/quejuan52.py

@@ -0,0 +1,69 @@
+'''
+Muestra ejemplos de asignación de variables "por valor" y "por referencia", según
+su tipo de dato.
+'''
+# asignacion por valor 
+
+from ast import Return
+
+
+my_variable = "hola"
+my_new_variable = my_variable
+my_new_variable = "mundo"
+
+print(my_variable)
+print(my_new_variable)
+
+#asignacion por referencia
+
+my_list = [3,4,67,10]
+my_new_list = my_list
+my_new_list [3] = "hello"
+
+print(my_list)         #salida: my_list =[3,4,67"hello"]
+print(my_new_list)     #salida: my_new_list =[3,4,67"hello"]
+
+'''
+Muestra ejemplos de funciones con variables que se les pasan "por valor" y 
+"por referencia", y cómo se comportan en cada caso en el momento de ser modificadas
+'''
+# funcion con variable por valor
+
+def my_function (my_variable):
+    print(my_variable)   # variable original no se ve afectada 
+
+# funcion con variable por referencia 
+    
+def variable_referencia(my_list):
+    my_list.append(5)
+    print(my_list)       # variable original si ve afectada 
+
+'''
+DIFICULTAD EXTRA (opcional):
+ * Crea dos programas que reciban dos parámetros (cada uno) definidos como variables anteriormente.
+ * - Cada programa recibe, en un caso, dos parámetros por valor, y en otro caso, por referencia.
+ *   Estos parámetros los intercambia entre ellos en su interior, los retorna, y su retorno
+ *   se asigna a dos variables diferentes a las originales. A continuación, imprime el valor de las
+ *   variables originales y las nuevas, comprobando que se ha invertido su valor en las segundas.
+ *   Comprueba también que se ha conservado el valor original en las primeras.
+'''
+
+def intercambio_valor(value1,value2):
+    
+    value_temp = value1
+    value1 = value2 
+    value2 = value_temp
+
+    return value1, value2
+
+# variables originales 
+valor1 = 34
+valor2 = 15
+
+# llamado de la funcion y asignacion a los nuevas variables los valores
+valor_new1, valor_new2 = intercambio_valor(valor1,valor2)
+
+print('valores orginales: ',valor1,valor2)
+print('\nvalores intercambiados: ',valor_new1,valor_new2)
+
+